#

luxiaotao1123

2022-04-24 c1eee79b96d70a3e93d84f88865dcd0bb30f0ab3

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

@@ -4,6 +4,8 @@
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.core.common.BaseRes;
import com.core.common.Cools;
import com.core.common.DateUtils;
import com.core.common.SnowflakeIdWorker;
import com.core.exception.CoolException;
import com.zy.asrs.entity.*;
import com.zy.asrs.entity.param.EmptyPlateOutParam;
@@ -11,19 +13,24 @@
import com.zy.asrs.entity.param.LocDetlAdjustParam;
import com.zy.asrs.entity.param.StockOutParam;
import com.zy.asrs.service.*;
import com.zy.common.model.LocDetlDto;
import com.zy.common.model.OutLocDto;
import com.zy.common.model.StartupDto;
import com.zy.common.model.*;
import com.zy.common.model.enums.IoWorkType;
import com.zy.common.model.enums.WorkNoType;
import com.zy.common.service.CommonService;
import com.zy.common.web.WcsController;
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.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 {

@@ -33,13 +40,15 @@
    private static final int DEFAULT_ROW_NO_TYPE = 1;

    @Autowired
    private MatService matService;
    @Autowired
    private WrkMastService wrkMastService;
    @Autowired
    private WrkDetlService wrkDetlService;
    @Autowired
    private BasDevpService basDevpService;
    @Autowired
    private CommonService commonService;
    @Autowired
    private WrkDetlService wrkDetlService;
    @Autowired
    private LocMastService locMastService;
    @Autowired
@@ -47,13 +56,19 @@
    @Autowired
    private LocDetlService locDetlService;
    @Autowired
    private MatCodeService matCodeService;
    @Autowired
    private AdjDetlService adjDetlService;
    @Autowired
    private WrkMastLogService wrkMastLogService;
    @Autowired
    private WrkDetlLogService wrkDetlLogService;
    @Autowired
    private SnowflakeIdWorker snowflakeIdWorker;
    @Autowired
    private OrderService orderService;
    @Autowired
    private OrderDetlService orderDetlService;
    @Autowired
    private WcsController wcsController;

    @Override
    @Transactional
@@ -62,19 +77,22 @@
        if (Cools.isEmpty(param.getDevpNo(), param.getList())) {
            throw new CoolException(BaseRes.PARAM);
        }
        Date now = new Date();
        // 源站点状态检测
        BasDevp sourceStaNo = basDevpService.checkSiteStatus(param.getDevpNo());
        // 生成工作号
        int workNo = commonService.getWorkNo(DEFAULT_WORK_NO_TYPE);
        BasDevp sourceStaNo = basDevpService.checkSiteStatus(param.getDevpNo(), true);
        // 检索库位
        StartupDto dto = commonService.getLocNo(DEFAULT_ROW_NO_TYPE, 1, param.getDevpNo());
        LocTypeDto locTypeDto = new LocTypeDto(sourceStaNo);
        List<String> matnrs = param.getList().stream().map(FullStoreParam.MatCodeStore::getMatnr).distinct().collect(Collectors.toList());
        StartupDto dto = commonService.getLocNo(DEFAULT_ROW_NO_TYPE, 1, param.getDevpNo(), matnrs, locTypeDto, 0);
        // 生成工作号
        int workNo = dto.getWorkNo();
        // 生成工作档
        WrkMast wrkMast = new WrkMast();
        wrkMast.setWrkNo(workNo);
        wrkMast.setIoTime(new Date());
        wrkMast.setWrkSts(1L); // 工作状态：生成入库ID
        wrkMast.setIoType(1); // 入出库状态：1.入库
        wrkMast.setIoPri(13D); // 优先级：10
        wrkMast.setIoPri(13D); // 优先级：13
        wrkMast.setCrnNo(dto.getCrnNo());
        wrkMast.setSourceStaNo(dto.getSourceStaNo());
        wrkMast.setStaNo(dto.getStaNo());
@@ -86,34 +104,39 @@
        wrkMast.setEmptyMk("N"); // 空板
        wrkMast.setLinkMis("N");
        wrkMast.setCtnType(sourceStaNo.getCtnType()); // 容器类型
        // 操作人员数据
        wrkMast.setAppeUser(userId);
        wrkMast.setAppeTime(new Date());
        wrkMast.setAppeTime(now);
        wrkMast.setModiUser(userId);
        wrkMast.setModiTime(new Date());
        boolean res = wrkMastService.insert(wrkMast);
        if (!res) {
        wrkMast.setModiTime(now);
        if (!wrkMastService.insert(wrkMast)) {
            throw new CoolException("保存工作档失败");
        }
        // 生成工作档明细
        List<MatCodeCountDto> matDtos = new ArrayList<>();
        List<DetlDto> detlDtos = new ArrayList<>();
        param.getList().forEach(elem -> {
            matDtos.add(new MatCodeCountDto(elem.getMatNo(), elem.getCount()));
            DetlDto detlDto = new DetlDto(elem.getMatnr(), elem.getBatch(), elem.getAnfme());
            if (DetlDto.has(detlDtos, detlDto)) {
                DetlDto detlDto1 = DetlDto.find(detlDtos, detlDto.getMatnr(), detlDto.getBatch());
                assert detlDto1 != null;
                detlDto1.setAnfme(detlDto1.getAnfme() + detlDto.getAnfme());
            } else {
                detlDtos.add(detlDto);
            }
        });
        wrkDetlService.createWorkDetail(workNo, matDtos, param.getBarcode(), userId);
        wrkDetlService.createWorkDetail(workNo, detlDtos, param.getBarcode(), userId);
        // 更新源站点信息
        sourceStaNo.setWrkNo(workNo);
        sourceStaNo.setModiUser(userId);
        sourceStaNo.setModiTime(new Date());
        sourceStaNo.setModiTime(now);
        if (!basDevpService.updateById(sourceStaNo)){
            throw new CoolException("更新源站失败");
        }
        // 更新目标库位状态
        LocMast locMast = locMastService.selectById(dto.getLocNo());
        if (locMast.getLocType().equals("O")){
            locMast.setLocType("S"); // S.入库预约
        if (locMast.getLocSts().equals("O")){
            locMast.setLocSts("S"); // S.入库预约
            locMast.setModiUser(userId);
            locMast.setModiTime(new Date());
            locMast.setModiTime(now);
            if (!locMastService.updateById(locMast)){
                throw new CoolException("改变库位状态失败");
            }
@@ -132,10 +155,7 @@
        List<LocDetlDto> locDetlDtos = new ArrayList<>();
        for (StockOutParam.LocDetl paramLocDetl : param.getLocDetls()) {
            if (!Cools.isEmpty(paramLocDetl.getLocNo(), paramLocDetl.getMatnr(), paramLocDetl.getCount())) {
                LocDetl sqlParam = new LocDetl();
                sqlParam.setLocNo(paramLocDetl.getLocNo());
                sqlParam.setMatnr(paramLocDetl.getMatnr());
                LocDetl one = locDetlService.selectOne(new EntityWrapper<>(sqlParam));
                LocDetl one = locDetlService.selectItem(paramLocDetl.getLocNo(), paramLocDetl.getMatnr(), paramLocDetl.getBatch());
                if (null != one) locDetlDtos.add(new LocDetlDto(one, paramLocDetl.getCount()));
            }
        }
@@ -143,52 +163,51 @@
            // 启动出库开始 101.出库
            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) {
    public void stockOut(BasDevp staNo, List<LocDetlDto> locDetlDtos, IoWorkType ioWorkType, Long userId) {
        Date now = new Date();
        // 合并同类项
        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();
        for (LocDetlDto locDetlDto : locDetlDtos) {
            String locNo = locDetlDto.getLocDetl().getLocNo();
            if (locNos.contains(locNo)) {
                for (OutLocDto dto : dtos) {
                    if (dto.getLocNo().equals(locNo)) {
                        dto.getLocDetlDtos().add(locDetlDto);
                        break;
                    }
                }
            } else {
                locNos.add(locNo);
                dtos.add(new OutLocDto(locNo, locDetlDto));
            }
            dtos.add(new OutLocDto(locNo, list));
        }
        Integer ioType = null;
        // 生成工作档
        for (OutLocDto dto : dtos) {
            // 判断入出库类型：101.全板出库 or 103.拣料出库
            if (ioType == null) {
            if (ioWorkType == null) {
                ioType = dto.isAll() ? 101 : 103;
            } else if (ioWorkType.equals(IoWorkType.CHECK_OUT)) {
                ioType = 107;
            }
            assert ioType != null;
            // 获取库位
            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("出库路径不存在");
            }
            StaDesc staDesc = staDescService.queryCrnStn(ioType, locMast.getCrnNo(), staNo.getDevNo());
            // 生成工作号
            int workNo = commonService.getWorkNo(DEFAULT_WORK_NO_TYPE);
            int workNo = commonService.getWorkNo(WorkNoType.getWorkNoType(ioType));
            // 生成工作档
            WrkMast wrkMast = new WrkMast();
            wrkMast.setWrkNo(workNo);
            wrkMast.setIoTime(new Date());
            wrkMast.setIoTime(now);
            wrkMast.setWrkSts(11L); // 工作状态：11.生成出库ID
            wrkMast.setIoType(ioType); // 入出库状态
            wrkMast.setIoPri(13D); // 优先级：13
@@ -202,32 +221,25 @@
            wrkMast.setEmptyMk("N"); // 空板
            wrkMast.setLinkMis("N");
            wrkMast.setAppeUser(userId); // 操作人员数据
            wrkMast.setAppeTime(new Date());
            wrkMast.setAppeTime(now);
            wrkMast.setModiUser(userId);
            wrkMast.setModiTime(new Date());
            wrkMast.setModiTime(now);
            if (!wrkMastService.insert(wrkMast)) {
                throw new CoolException("保存工作档失败，出库库位号："+dto.getLocNo());
            }
            // 生成工作档明细
            for (LocDetlDto detlDto : dto.getLocDetlDtos()) {
                // 出库时，数量为0的直接忽略
                if (detlDto.getCount()==null || detlDto.getCount() <= 0.0D) {continue;}
                WrkDetl wrkDetl = new WrkDetl();
                wrkDetl.sync(detlDto.getLocDetl());
                wrkDetl.setOrderNo(""); // 手动出库不需要带出库存中的单据编号
                wrkDetl.setWrkNo(workNo);
                wrkDetl.setIoTime(new Date());
                wrkDetl.setMatnr(detlDto.getLocDetl().getMatnr());
                Double anfme = ioType==101?detlDto.getCount():detlDto.getLocDetl().getAnfme();
                wrkDetl.setIoTime(now);
                Double anfme = ioType==101?detlDto.getLocDetl().getAnfme():detlDto.getCount();
                wrkDetl.setAnfme(anfme); // 数量
                wrkDetl.setZmatid(detlDto.getLocDetl().getZmatid());
                wrkDetl.setTbpos(detlDto.getLocDetl().getTbpos());
                wrkDetl.setTbnum(detlDto.getLocDetl().getTbnum());
                wrkDetl.setLgnum(detlDto.getLocDetl().getLgnum());
                wrkDetl.setAltme(detlDto.getLocDetl().getAltme());
                wrkDetl.setBname(detlDto.getLocDetl().getBname());
                wrkDetl.setMaktx(detlDto.getLocDetl().getMaktx());
                wrkDetl.setAppeTime(new Date());
                wrkDetl.setAppeTime(now);
                wrkDetl.setAppeUser(userId);
                wrkDetl.setModiTime(new Date());
                wrkDetl.setModiTime(now);
                wrkDetl.setModiUser(userId);
                if (!wrkDetlService.insert(wrkDetl)) {
                    throw new CoolException("保存工作档明细失败");
@@ -235,10 +247,10 @@
            }
            // 修改库位状态:   F.在库 ====>>> R.出库预约/P.拣料/盘点/并板出库中
            locMast = locMastService.selectById(dto.getLocNo());
            if (locMast.getLocType().equals("F")) {
                locMast.setLocType(ioType==101?"R":"P");
            if (locMast.getLocSts().equals("F")) {
                locMast.setLocSts(ioType==101?"R":"P");
                locMast.setModiUser(userId);
                locMast.setModiTime(new Date());
                locMast.setModiTime(now);
                if (!locMastService.updateById(locMast)) {
                    throw new CoolException("预约库位状态失败，库位号："+dto.getLocNo());
                }
@@ -250,25 +262,103 @@

    @Override
    @Transactional
    public void stockOut(BasDevp staNo, TaskDto taskDto, Long userId) {
        Date now = new Date();
        List<LocDto> locDtos = taskDto.getLocDtos();
        for (LocDto locDto : locDtos) {
            if (!taskDto.getLocNo().equals(locDto.getLocNo()) && !taskDto.getStaNo().equals(locDto.getStaNo())) {
                throw new CoolException("订单出库异常，请联系管理员");
            }
        }
        // 获取库位
        LocMast locMast = locMastService.selectById(taskDto.getLocNo());
        // 获取路径
        int ioType = taskDto.isAll() ? 101 : 103;
        StaDesc staDesc = staDescService.queryCrnStnAuto(ioType, locMast.getCrnNo(), staNo.getDevNo());
        // 生成工作号
        int workNo = commonService.getWorkNo(WorkNoType.getWorkNoType(ioType));
        // 生成工作档
        WrkMast wrkMast = new WrkMast();
        wrkMast.setWrkNo(workNo);
        wrkMast.setIoTime(now);
        wrkMast.setWrkSts(11L); // 工作状态：11.生成出库ID
        wrkMast.setIoType(ioType); // 入出库状态
        wrkMast.setIoPri(13D); // 优先级：13
        wrkMast.setCrnNo(locMast.getCrnNo());
        wrkMast.setSourceStaNo(staDesc.getCrnStn()); // 源站
        wrkMast.setStaNo(staDesc.getStnNo()); // 目标站
        wrkMast.setSourceLocNo(taskDto.getLocNo()); // 源库位
        wrkMast.setFullPlt("Y"); // 满板：Y
        wrkMast.setPicking("N"); // 拣料
        wrkMast.setExitMk("N"); // 退出
        wrkMast.setEmptyMk("N"); // 空板
        wrkMast.setLinkMis("N");
        wrkMast.setAppeUser(userId); // 操作人员数据
        wrkMast.setAppeTime(now);
        wrkMast.setModiUser(userId);
        wrkMast.setModiTime(now);
        if (!wrkMastService.insert(wrkMast)) {
            throw new CoolException("保存工作档失败，出库库位号："+taskDto.getLocNo());
        }
        // 生成工作档明细
        for (LocDto locDto : taskDto.getLocDtos()) {
            if (locDto.getAnfme()==null || locDto.getAnfme() <= 0.0D) { continue; }
            OrderDetl orderDetl = orderDetlService.selectItem(locDto.getOrderNo(), locDto.getMatnr(), locDto.getBatch());
            WrkDetl wrkDetl = new WrkDetl();
            wrkDetl.sync(orderDetl);
            wrkDetl.setIoTime(now);
            wrkDetl.setWrkNo(workNo);
            wrkDetl.setBatch(locDto.getBatch());
            wrkDetl.setOrderNo(locDto.getOrderNo());
            wrkDetl.setAnfme(locDto.getAnfme()); // 数量
            wrkDetl.setAppeTime(now);
            wrkDetl.setAppeUser(userId);
            wrkDetl.setModiTime(now);
            wrkDetl.setModiUser(userId);
            if (!wrkDetlService.insert(wrkDetl)) {
                throw new CoolException("保存工作档明细失败");
            }
            // 修改订单明细
            if (!orderDetlService.increase(orderDetl.getOrderId(), orderDetl.getMatnr(), orderDetl.getBatch(), locDto.getAnfme())) {
                throw new CoolException("修改订单明细数量失败");
            }
            orderService.updateSettle(orderDetl.getOrderId(), 2L, userId);
        }
        // 修改库位状态:   F.在库 ====>>> R.出库预约/P.拣料/盘点/并板出库中
        locMast = locMastService.selectById(taskDto.getLocNo());
        if (locMast.getLocSts().equals("F")) {
            locMast.setLocSts(ioType==101?"R":"P");
            locMast.setModiUser(userId);
            locMast.setModiTime(now);
            if (!locMastService.updateById(locMast)) {
                throw new CoolException("预约库位状态失败，库位号："+taskDto.getLocNo());
            }
        } else {
            throw new CoolException(taskDto.getLocNo() + "库位不是在库状态");
        }
    }

    @Override
    @Transactional
    public String emptyPlateIn(Integer devpNo, Long userId) {
        // 源站点状态检测
        BasDevp sourceStaNo = basDevpService.checkSiteStatus(devpNo);
        // 生成工作号
        int workNo = commonService.getWorkNo(DEFAULT_WORK_NO_TYPE);
        BasDevp sourceStaNo = basDevpService.checkSiteStatus(devpNo, true);
        // 检索库位
        StartupDto dto = commonService.getLocNo(DEFAULT_ROW_NO_TYPE, 10, devpNo);
        LocTypeDto locTypeDto = new LocTypeDto(sourceStaNo);
        StartupDto dto = commonService.getLocNo(DEFAULT_ROW_NO_TYPE, 10, devpNo, null, locTypeDto, 0);
        int workNo = dto.getWorkNo();
        // 生成工作档
        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"); // 空板
@@ -292,8 +382,8 @@
        }
        // 更新目标库位状态
        LocMast locMast = locMastService.selectById(dto.getLocNo());
        if (locMast.getLocType().equals("O")){
            locMast.setLocType("S"); // S.入库预约
        if (locMast.getLocSts().equals("O")){
            locMast.setLocSts("S"); // S.入库预约
            locMast.setModiUser(userId);
            locMast.setModiTime(new Date());
            if (!locMastService.updateById(locMast)){
@@ -313,7 +403,7 @@
        }
        for (String locNo : param.getLocNos()) {
            // 获取工作号
            int workNo = commonService.getWorkNo(DEFAULT_WORK_NO_TYPE);
            int workNo = commonService.getWorkNo(WorkNoType.PAKOUT.type);
            // 获取库位
            LocMast locMast = locMastService.selectById(locNo);
            if (Cools.isEmpty(locMast)) {
@@ -354,15 +444,14 @@
                throw new CoolException("保存工作档失败");
            }
            // 更新库位状态 D.空板 -> R.出库预约
            if (locMast.getLocType().equals("D")){
                locMast.setLocType("R");
            if (locMast.getLocSts().equals("D")){
                locMast.setLocSts("R");
                locMast.setModiUser(userId);
                locMast.setModiTime(new Date());
                if (!locMastService.updateById(locMast)) {
                    throw new CoolException("更新库位状态失败");
                }
            }
            // todo 更新站点信息（工作号）
        }
    }

@@ -374,17 +463,14 @@
        // 获取库位明细
        List<LocDetlDto> locDetlDtos = new ArrayList<>();
        for (StockOutParam.LocDetl paramLocDetl : param.getLocDetls()) {
            if (!Cools.isEmpty(paramLocDetl.getLocNo(), paramLocDetl.getMatnr())) {
                LocDetl sqlParam = new LocDetl();
                sqlParam.setLocNo(paramLocDetl.getLocNo());
                sqlParam.setMatnr(paramLocDetl.getMatnr());
                LocDetl one = locDetlService.selectOne(new EntityWrapper<>(sqlParam));
                if (null != one) locDetlDtos.add(new LocDetlDto(one, one.getAnfme()));
            if (!Cools.isEmpty(paramLocDetl.getLocNo(), paramLocDetl.getMatnr(), paramLocDetl.getCount())) {
                LocDetl one = locDetlService.selectItem(paramLocDetl.getLocNo(), paramLocDetl.getMatnr(), paramLocDetl.getBatch());
                if (null != one) locDetlDtos.add(new LocDetlDto(one, paramLocDetl.getCount()));
            }
        }
        if (!locDetlDtos.isEmpty()) {
            // 启动出库开始 107.盘点出库
            stockOut(staNo, locDetlDtos, 107, userId);
            stockOut(staNo, locDetlDtos, IoWorkType.CHECK_OUT, userId);
        } else {
            throw new CoolException("库位物料不存在");
        }
@@ -394,6 +480,7 @@
    @Transactional
    public void locMove(String sourceLocNo, String locNo, Long userId) {
        LocMast sourceLoc = locMastService.selectById(sourceLocNo);
        List<LocDetl> locDetls = locDetlService.selectList(new EntityWrapper<LocDetl>().eq("loc_no", sourceLocNo));
        if (Cools.isEmpty(sourceLoc)){
            throw new CoolException("未找到库位");
        }
@@ -405,7 +492,7 @@
            throw new CoolException("移转库位属于不同堆垛机");
        }
        // 获取工作号
        int workNo = commonService.getWorkNo(DEFAULT_WORK_NO_TYPE);
        int workNo = commonService.getWorkNo(WorkNoType.PICK.type);
        // 保存工作档
        WrkMast wrkMast = new WrkMast();
        wrkMast.setWrkNo(workNo);
@@ -416,10 +503,11 @@
        wrkMast.setCrnNo(sourceLoc.getCrnNo());
        wrkMast.setSourceLocNo(sourceLocNo); // 源库位
        wrkMast.setLocNo(locNo); // 目标库位
        wrkMast.setFullPlt("N"); // 满板：Y
        wrkMast.setFullPlt(Cools.isEmpty(locDetls)?"N":"Y"); // 满板：Y
        wrkMast.setPicking("N"); // 拣料
        wrkMast.setExitMk("N"); // 退出
        wrkMast.setEmptyMk(sourceLoc.getLocType().equals("D")?"Y":"N"); // 空板
        wrkMast.setEmptyMk(sourceLoc.getLocSts().equals("D")?"Y":"N"); // 空板
        wrkMast.setBarcode(sourceLoc.getBarcode()); // 托盘码
        wrkMast.setLinkMis("N");
        wrkMast.setAppeUser(userId);
        wrkMast.setAppeTime(new Date());
@@ -430,20 +518,12 @@
            throw new CoolException("保存工作档失败");
        }
        // 工作档明细保存
        List<LocDetl> locDetls = locDetlService.selectList(new EntityWrapper<LocDetl>().eq("loc_no", sourceLocNo));
        for (LocDetl locDetl : locDetls) {
            WrkDetl wrkDetl = new WrkDetl();
            wrkDetl.sync(locDetl);
            wrkDetl.setWrkNo(workNo);
            wrkDetl.setIoTime(new Date());
            wrkDetl.setMatnr(locDetl.getMatnr());
            wrkDetl.setAnfme(locDetl.getAnfme());
            wrkDetl.setZmatid(locDetl.getZmatid());
            wrkDetl.setTbpos(locDetl.getTbpos());
            wrkDetl.setTbnum(locDetl.getTbnum());
            wrkDetl.setLgnum(locDetl.getLgnum());
            wrkDetl.setAltme(locDetl.getAltme());
            wrkDetl.setBname(locDetl.getBname());
            wrkDetl.setMaktx(locDetl.getMaktx());
            wrkDetl.setAppeTime(new Date());
            wrkDetl.setAppeUser(userId);
            wrkDetl.setModiTime(new Date());
@@ -453,26 +533,26 @@
            }
        }
        // 修改源库位状态
        if (sourceLoc.getLocType().equals("D") || sourceLoc.getLocType().equals("F")) {
            sourceLoc.setLocType("R"); // R.出库预约
        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.getLocType$());
            throw new CoolException("源库位出库失败，状态："+sourceLoc.getLocSts$());
        }
        // 修改目标库位状态
        if (loc.getLocType().equals("O")) {
            loc.setLocType("S"); // S.入库预约
        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.getLocType$());
            throw new CoolException("移转失败，目标库位状态："+loc.getLocSts$());
        }
    }

@@ -493,8 +573,13 @@
        } else if (wrkMast.getWrkSts() > 10) {
            wrkMast.setWrkSts(14L);
        }
        wrkMast.setModiTime(new Date());
        Date now = new Date();
        wrkMast.setCrnStrTime(DateUtils.calculate(now, 1L, TimeUnit.SECONDS, true));
        wrkMast.setCrnEndTime(now);
        wrkMast.setModiTime(now);
        wrkMast.setModiUser(userId);
        // 完成操作人员记录
        wrkMast.setManuType("手动完成");
        if (!wrkMastService.updateById(wrkMast)) {
            throw new CoolException("修改工作档失败");
        }
@@ -503,82 +588,123 @@
    @Override
    @Transactional
    public void adjustLocDetl(LocDetlAdjustParam param, Long userId) {
        param.integrate();
        LocMast locMast = locMastService.selectById(param.getLocNo());
        if (Cools.isEmpty(locMast)) {
            throw new CoolException("库位不存在");
        }
        for (LocDetlAdjustParam.LocDetlAdjust adjust : param.getList()) {
            if (Cools.isEmpty(adjust.getMatnr())) {
                throw new CoolException(BaseRes.PARAM);
            }
            LocDetl sqlParam = new LocDetl();
            sqlParam.setLocNo(locMast.getLocNo());
            sqlParam.setMatnr(adjust.getMatnr());
            LocDetl one = locDetlService.selectOne(new EntityWrapper<>(sqlParam));
            // 保存新库存明细
            if (Cools.isEmpty(one)) {
                if (adjust.getCount() == 0){
                    continue;
                }
                MatCode matCode = matCodeService.selectById(adjust.getMatnr());
                LocDetl locDetl = new LocDetl();
                locDetl.setLocNo(locMast.getLocNo());
                locDetl.setMatnr(matCode.getMatNo());
                locDetl.setMaktx(matCode.getMatName()); // 物料描述
                locDetl.setAnfme(adjust.getCount()); // 数量
                locDetl.setAltme(matCode.getStr1()); // 单位
                // todo:luxiaoao
                locDetl.setLgnum("待定"); // 仓库号
                locDetl.setTbnum(0); // 转储请求编号
                locDetl.setTbpos(0); // 行项目
                locDetl.setZmatid("待定"); // 物料标签ID
                locDetl.setZpallet("待定"); // 托盘条码
        if (!(locMast.getLocSts().equals("F") || locMast.getLocSts().equals("D") || locMast.getLocSts().equals("O"))) {
            throw new CoolException("当前库位不可调整！库位状态：" + locMast.getLocSts$());
        }

                locDetl.setModiUser(userId); // 操作人员信息
                locDetl.setModiTime(new Date());
                locDetl.setAppeUser(userId);
                locDetl.setAppeTime(new Date());
                if (!locDetlService.insert(locDetl)) {
                    throw new CoolException("保存库存明细失败");
                }
                // 保存调整记录
                AdjDetl adjDetl = new AdjDetl();
                adjDetl.setLocNo(locDetl.getLocNo());
                adjDetl.setMatNo(locDetl.getMatnr());
                adjDetl.setOriQty(0.0D);
                adjDetl.setAdjQty(adjust.getCount());
                adjDetlService.save(adjDetl, userId);
            // 修改原库存明细
            } else {
                // 如果数量修改，则更新库存明细
                if (!adjust.getCount().equals(one.getAnfme())) {
                    // 当数量被修改为 0 时，直接清除库存明细
                    if (adjust.getCount() == 0) {
                        if (!locDetlService.delete(new EntityWrapper<>(one))) {
                            throw new CoolException("清除库存明细失败");
        Date now = new Date();
        List<LocDetl> locDetls = locDetlService.selectList(new EntityWrapper<LocDetl>().eq("loc_no", param.getLocNo()));

        List<LocDetlAdjustParam.LocDetlAdjust> list = param.getList();

        // 修改数量
        Iterator<LocDetl> iterator = locDetls.iterator();
        while (iterator.hasNext()) {
            LocDetl locDetl = iterator.next();

            Iterator<LocDetlAdjustParam.LocDetlAdjust> iterator1 = list.iterator();
            while (iterator1.hasNext()) {
                LocDetlAdjustParam.LocDetlAdjust adjust = iterator1.next();
                if (adjust.getCount() == 0) { continue; }
                if (locDetl.getMatnr().equals(adjust.getMatnr()) && Cools.eq(locDetl.getBatch(), adjust.getBatch())) {
                    if (!locDetl.getAnfme().equals(adjust.getCount())) {
                        // todo 盘点记录
                        // 修改库存
                        if (!locDetlService.updateAnfme(adjust.getCount(), locDetl.getLocNo(), locDetl.getMatnr(), locDetl.getBatch())) {
                            throw new CoolException(locDetl.getLocNo() + "库位，" + locDetl.getMatnr() + "商品，" + locDetl.getBatch() + "序列码修改数量失败");
                        }
                    } else {
                        LocDetl sqlParam1 = new LocDetl();
                        sqlParam1.setAnfme(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()))) {
                            throw new CoolException("修改库存明细失败");
                        }
                        // 保存调整记录
                        AdjDetl adjDetl = new AdjDetl();
                        adjDetl.setLocNo(locDetl.getLocNo());
                        adjDetl.setMatnr(locDetl.getMatnr());
                        adjDetl.setBatch(locDetl.getBatch());
                        adjDetl.setOriQty(locDetl.getAnfme());
                        adjDetl.setAdjQty(adjust.getCount());
                        adjDetl.setModiTime(now);
                        adjDetl.setModiUser(userId);
                        adjDetl.setAppeTime(now);
                        adjDetl.setAppeUser(userId);
                        adjDetlService.save(adjDetl, userId);
                    }
                    // 保存调整记录
                    AdjDetl adjDetl = new AdjDetl();
                    adjDetl.setLocNo(locMast.getLocNo());
                    adjDetl.setMatNo(adjust.getMatnr());
                    adjDetl.setOriQty(one.getAnfme());
                    adjDetl.setAdjQty(adjust.getCount());
                    adjDetlService.save(adjDetl, userId);
                    iterator.remove();
                    iterator1.remove();
                }
            }
        }

        // 删除库存
        for (LocDetl locDetl : locDetls) {
            // todo 盘点记录
            if (!locDetlService.updateAnfme(-1.0D, locDetl.getLocNo(), locDetl.getMatnr(), locDetl.getBatch())) {
                throw new CoolException("删除" + locDetl.getLocNo() + "库位，" + locDetl.getMatnr() + "商品，" + locDetl.getBatch() + "序列码库存明细失败");
            }
            // 保存调整记录
            AdjDetl adjDetl = new AdjDetl();
            adjDetl.setLocNo(locDetl.getLocNo());
            adjDetl.setMatnr(locDetl.getMatnr());
            adjDetl.setBatch(locDetl.getBatch());
            adjDetl.setOriQty(locDetl.getAnfme());
            adjDetl.setAdjQty(0.0D);
            adjDetl.setModiTime(now);
            adjDetl.setModiUser(userId);
            adjDetl.setAppeTime(now);
            adjDetl.setAppeUser(userId);
            adjDetlService.save(adjDetl, userId);
        }

        // 添加库存
        for (LocDetlAdjustParam.LocDetlAdjust adjust : list) {
            if (adjust.getCount() == 0.0D) { continue; }
            Mat mat = matService.selectByMatnr(adjust.getMatnr());
            LocDetl locDetl = new LocDetl();
            locDetl.sync(mat);
            locDetl.setBatch(adjust.getBatch());
            locDetl.setLocNo(locMast.getLocNo());
            locDetl.setAnfme(adjust.getCount()); // 数量
            locDetl.setModiUser(userId); // 操作人员信息
            locDetl.setModiTime(now);
            locDetl.setAppeUser(userId);
            locDetl.setAppeTime(now);
            if (!locDetlService.insert(locDetl)) {
                throw new CoolException("添加" + locDetl.getLocNo() + "库位，" + locDetl.getMatnr() + "商品，" + locDetl.getBatch() + "序列码库存明细失败");
            }
            // 保存调整记录
            AdjDetl adjDetl = new AdjDetl();
            adjDetl.setLocNo(locMast.getLocNo());
            adjDetl.setMatnr(adjust.getMatnr());
            adjDetl.setBatch(adjust.getBatch());
            adjDetl.setOriQty(0.0D);
            adjDetl.setAdjQty(adjust.getCount());
            adjDetl.setModiTime(now);
            adjDetl.setModiUser(userId);
            adjDetl.setAppeTime(now);
            adjDetl.setAppeUser(userId);
            adjDetlService.save(adjDetl, userId);
        }
        // 修改库位状态
        int count = locDetlService.selectCount(new EntityWrapper<LocDetl>().eq("loc_no", locMast.getLocNo()));
        if (locMast.getLocSts().equals("F")) {
            if (count == 0) {
                locMast.setLocSts("D");
            }
        }
        if (locMast.getLocSts().equals("D") || locMast.getLocSts().equals("O")) {
            if (count > 0) {
                locMast.setLocSts("F");
            }
        }
        locMast.setModiUser(userId);
        locMast.setModiTime(new Date());
        if (!locMastService.updateById(locMast)) {
            throw new CoolException("更新库位状态失败");
        }
    }


    @Override
    @Transactional
@@ -588,11 +714,11 @@
            throw new CoolException(workNo+"工作档不存在");
        }
        String locNo = ""; // 待修改目标库位
        String locType = ""; // 待修改目标库位状态
        String locSts = ""; // 待修改目标库位状态
        // 入库取消（修改目标库位）
        if (wrkMast.getWrkSts() < 4) {
            locNo = wrkMast.getLocNo();
            locType = "O";
            locSts = "O";
            /**
             * 库位转移
             * 取消后 源库位 ==>> F.在库
@@ -604,7 +730,7 @@
                if (Cools.isEmpty(locMast)) {
                    throw new CoolException("取消库位转移失败，源库位不存在:"+ wrkMast.getSourceLocNo());
                }
                locMast.setLocType("F");
                locMast.setLocSts("F");
                locMast.setModiTime(new Date());
                locMast.setModiUser(userId);
                locMastService.updateById(locMast);
@@ -614,19 +740,19 @@
            locNo = wrkMast.getSourceLocNo();
            // 出库 ===>> F.在库
            if (wrkMast.getIoType() > 100 && wrkMast.getIoType() != 110) {
                locType = "F";
                locSts = "F";
            // 空板出库 ===>> D.空桶/空栈板
            } else if (wrkMast.getIoType() == 110) {
                locType = "D";
                locSts = "D";
            // 库位转移 ===>> D.空桶/空栈板
            } else if (wrkMast.getIoType() == 11) {
                locType = "F";
                locSts = wrkMast.getFullPlt().equalsIgnoreCase("N")?"F":"D";
                // 库位转移：目标库位
                LocMast locMast = locMastService.selectById(wrkMast.getLocNo());
                if (Cools.isEmpty(locMast)) {
                    throw new CoolException("取消库位转移失败，目标库位不存在:"+ wrkMast.getSourceLocNo());
                }
                locMast.setLocType("O");
                locMast.setLocSts("O");
                locMast.setModiTime(new Date());
                locMast.setModiUser(userId);
                locMastService.updateById(locMast);
@@ -634,20 +760,50 @@
        } else {
            throw new CoolException("当前工作状态无法取消");
        }
        // 删除工作档
        // 订单关联
        List<WrkDetl> wrkDetls = wrkDetlService.selectByWrkNo(wrkMast.getWrkNo());
        for (WrkDetl wrkDetl : wrkDetls) {
            if (!Cools.isEmpty(wrkDetl.getOrderNo())) {
                if (!orderDetlService.decrease(wrkDetl.getOrderNo(), wrkDetl.getMatnr(), wrkDetl.getBatch(), wrkDetl.getAnfme())) {
                    throw new CoolException("订单数据回滚失败");
                }
                // 生成新的出库作业
//                        stockOutRe(wrkMast, wrkDetls);
            }
        }
        // 取消操作人员记录
        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)) {
            throw new CoolException("取消工作档失败，库位不存在:"+ locNo);
        }
        locMast.setLocType(locType);
        locMast.setLocSts(locSts);
        locMast.setModiTime(new Date());
        locMast.setModiUser(userId);
        boolean locMastRes = locMastService.updateById(locMast);
        if (!wrkMastRes || !wrkDetlRes || !locMastRes) {
        if (!wrkMastRes || !locMastRes) {
            throw new CoolException("保存数据失败");
        }
    }
@@ -659,8 +815,8 @@
        if (Cools.isEmpty(wrkMast)){
            throw new CoolException(workNo+"工作档不存在");
        }
        // 拣料作业判断
        if (wrkMast.getIoType() != 103 || wrkMast.getIoType() != 104 || wrkMast.getIoType() != 107) {
        // 入出库类型判断
        if (wrkMast.getIoType() != 103 && wrkMast.getIoType() != 104 && wrkMast.getIoType() != 107) {
            throw new CoolException("当前入出库类型无法进行操作");
        }
        // 工作状态判断
@@ -668,16 +824,16 @@
            throw new CoolException("当前工作状态无法进行操作");
        }
        // 保存工作明细档历史档
//        if (!wrkDetlLogService.save(wrkMast.getWrkNo())) {
//            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", 53)  // type_no: 53.拣料再入库
                .eq("type_no", wrkMast.getIoType() - 50)
                .eq("stn_no", wrkMast.getStaNo()) // 作业站点 = 拣料出库的目标站
                .eq("crn_no", wrkMast.getCrnNo()); // 堆垛机号
        StaDesc staDesc = staDescService.selectOne(wrapper);
@@ -687,7 +843,7 @@
        // 堆垛机站点(目标站)
        Integer staNo = staDesc.getCrnStn();
        // 更新工作档数据状态
        wrkMast.setIoType(wrkMast.getIoType() + 50); // 入出库类型: 53->103,54->104,57->107
        wrkMast.setIoType(wrkMast.getIoType() - 50); // 入出库类型: 103->53,104->54,107->57
        wrkMast.setWrkSts(2L); // 工作状态: 2.设备上走
        wrkMast.setSourceStaNo(wrkMast.getStaNo()); // 源站
        wrkMast.setStaNo(staNo); // 目标站
@@ -700,7 +856,7 @@
        }
        // 修改库位状态 Q.拣料/盘点/并板再入库
        LocMast locMast = locMastService.selectById(wrkMast.getLocNo());
        locMast.setLocType("Q");
        locMast.setLocSts("Q");
        locMast.setModiTime(new Date());
        locMast.setModiUser(userId);
        if (!locMastService.updateById(locMast)) {
@@ -708,4 +864,14 @@
        }
    }

    @Override
    public StartupDto createWaitPainWrkMastStart(List<WaitPakin> list, Long userId) {
        if (Cools.isEmpty(list)) {
            throw new CoolException("入库通知档不能为空");
        }
        LocTypeDto locTypeDto = new LocTypeDto();
        locTypeDto.setLocType1((short) 1);
        return wcsController.startupFullPutStore(301, list.get(0).getZpallet(), locTypeDto, list);
    }

}