#

lty

2 天以前 d8c9b9afb41c368a08d7e05d0f624c98bf72042a

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

@@ -1,8 +1,9 @@
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.common.DateUtils;
import com.core.common.R;
import com.core.common.SnowflakeIdWorker;
import com.core.exception.CoolException;
import com.zy.asrs.entity.*;
@@ -11,17 +12,21 @@
import com.zy.asrs.entity.result.StockVo;
import com.zy.asrs.mapper.TagMapper;
import com.zy.asrs.service.*;
import com.zy.asrs.utils.MatCompareUtils;
import com.zy.asrs.utils.MatUtils;
import com.zy.common.model.DetlDto;
import com.zy.common.model.enums.WorkNoType;
import com.zy.common.service.CommonService;
import com.zy.common.utils.NodeUtils;
import com.zy.third.erp.task.ERPOutHedTBScheduler;
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.ArrayList;
import javax.annotation.Resource;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;

/**
 * Created by vincent on 2022/4/9
@@ -48,6 +53,267 @@
    private TagService tagService;
    @Autowired
    private TagMapper tagMapper;

    @Resource
    private WaitPakinService waitPakinService;

    @Resource
    private WrkDetlService wrkDetlService;

    @Resource
    private WorkService workService;

    @Resource
    private BasDevpService basDevpService;

    @Resource
    private LocMastService locMastService;

    @Resource
    private StaDescService staDescService;

    @Resource
    private CommonService commonService;

    @Resource
    private WrkMastService wrkMastService;

    @Resource
    private ERPOutHedTBScheduler erpOutHedTBScheduler;


    @Override
    @Transactional
    public R grouping(AgvGroupingParam param) {

        if (Cools.isEmpty(param.getBarcode(), param.getCombMats())) {
            throw new CoolException(BaseRes.PARAM);
        }

        // 判断是否有相同条码的数据
        if (waitPakinService.selectCount(new EntityWrapper<WaitPakin>().
                eq("zpallet", param.getBarcode()).eq("io_status", "N")) > 0) {
            throw new CoolException(param.getBarcode() + "数据正在进行入库");
        }

        if (param.getBarcode().length() != 8) {
            throw new CoolException("条码长度不是8位===>>" + param.getBarcode());
        }

        int countLoc = locDetlService.selectCount(new EntityWrapper<LocDetl>().eq("zpallet", param.getBarcode()));
        int countWrk = wrkDetlService.selectCount(new EntityWrapper<WrkDetl>().eq("zpallet", param.getBarcode()));
        int countwait = waitPakinService.selectCount(new EntityWrapper<WaitPakin>().eq("zpallet", param.getBarcode()));
        if (countLoc > 0 || countWrk > 0 || countwait > 0) {
            throw new CoolException("组托档/工作档/库存条码数据已存在===>>" + param.getBarcode());
        }

        Date now = new Date();

        Order order = orderService.selectOne(new EntityWrapper<Order>().eq("temp1", param.getOrderNo()));
        if (Cools.isEmpty(order) || order.getSettle() > 2) {
            throw new CoolException("单据编号已过期");
        }
        // 生成入库通知档
        param.getCombMats().forEach(elem -> {

            // 订单明细数量校验
            OrderDetl orderDetl = orderDetlService.selectById(elem.getDetlId());
            if (elem.getAnfme() > orderDetl.getEnableQty()) {
                throw new CoolException(orderDetl.getMatnr() + "入库数量不合法");
            }
            // 修改订单作业数量
            if (!orderDetlService.increaseWorkQty(orderDetl, elem.getAnfme())) {
                throw new CoolException("修改单据作业数量失败");
            }

            Mat mat = matService.selectByMatnr(orderDetl.getMatnr());
            if (Cools.isEmpty(mat)) {
                throw new CoolException(orderDetl.getMatnr() + "商品档案不存在");
            }
            WaitPakin waitPakin = new WaitPakin();
            waitPakin.sync(mat);
            waitPakin.setOrderNo(order.getOrderNo());   // 单据编号
            waitPakin.setBatch(orderDetl.getBatch());     // 序列码
            waitPakin.setZpallet(param.getBarcode());   // 托盘码
            waitPakin.setIoStatus("N");     // 入出状态
            waitPakin.setAnfme(elem.getAnfme());  // 数量
            waitPakin.setStatus("Y");    // 状态
            waitPakin.setAppeTime(now);
            waitPakin.setModiTime(now);

            waitPakin.setBatch(orderDetl.getBatch());
            waitPakin.setSPgNO(orderDetl.getSPgNO());
            waitPakin.setOutOrderNo(orderDetl.getOutOrderNo());
            waitPakin.setProType(orderDetl.getProType());
            waitPakin.setLuHao(orderDetl.getLuHao());
            waitPakin.setPacking(orderDetl.getPacking());
            if (!waitPakinService.insert(waitPakin)) {
                throw new CoolException("保存入库通知档失败");
            }
        });

        orderService.updateSettle(order.getId(), 2L, null);
        return R.ok("组托成功");
    }

    @Override
    public R barcodeVerificatio(String barcode) {

        if (!barcode.matches("\\d{8}")) {
            return R.parse("条码不是8位数字：" + barcode);
        }

        int countLoc = locDetlService.selectCount(new EntityWrapper<LocDetl>().eq("zpallet", barcode));
        int countWrk = wrkDetlService.selectCount(new EntityWrapper<WrkDetl>().eq("zpallet", barcode));
        int countwait = waitPakinService.selectCount(new EntityWrapper<WaitPakin>().eq("zpallet", barcode));

        if (countLoc > 0) {
            return R.parse("库存已存在该条码：" + barcode);
        } else if (countWrk > 0) {
            return R.parse("该条码已生成工作档：" + barcode);
        } else if (countwait > 0) {
            return R.parse("该条码已生成入库通知档：" + barcode);
        }

        return R.ok("校验成功");
    }

    @Override
    @Transactional
    public R outbound(OutBoundParam param) {

        // 托盘码
        String barcode = param.getBarcode();

        // 单据编号
        String orderNo = param.getOrderNo();

        // 根据托盘码查询库存明细
        List<LocDetl> locDetls = locDetlService.selectList(new EntityWrapper<LocDetl>().eq("zpallet", barcode));
        List<String> locNos = locDetls.stream().map(LocDetl::getLocNo).distinct().collect(Collectors.toList());
        if (locDetls.size() == 0) {
            return R.parse("该托盘码不存在库存：" + barcode);
        } else if (locNos.size() > 1) {
            return R.parse("该托盘码有多个库位：" + barcode);
        }

        // 库位号
        String locNo = locNos.get(0);

        // 出库站点
        Integer outSite = null;
        List<BasDevp> devps = basDevpService.selectList(new EntityWrapper<BasDevp>().in("dev_no", 223, 123));
        for (BasDevp basDevp : devps) {
            // 无工作号，无物
            if (basDevp.getWrkNo() == 0 && basDevp.getLoading().equals("N")) {
                outSite = basDevp.getDevNo();
                break;
            }
        }
        if (outSite == null) {
            outSite = 123;
        }

        Date now = new Date();

        // 获取单据
        Order order = orderService.selectByNo(orderNo);
        if (order == null) {
            erpOutHedTBScheduler.OutHedTBScheduler(orderNo);
            order = orderService.selectByNo(orderNo);
//            int i = 30;
//            while (i >= 0) {
//                try {
//                    Thread.sleep(1000);
//                    System.out.println(i);
//                } catch (InterruptedException e) {
//                    throw new RuntimeException(e);
//                }
//                order = orderService.selectByNo(orderNo);
//                if (order != null) {
//                    break;
//                }
//                i--;
//            }
        }
        if (order == null) {
            return R.parse("单据不存在：" + orderNo);
        }
        // 获取单据明细
        List<OrderDetl> orderDetlList = orderDetlService.selectByOrderId(order.getId());

        // 对比库存明细和出库单据明细是否一致
        boolean flag = MatCompareUtils.compareAndCheckCancellation(locDetls, orderDetlList);
        if (!flag) {
            return R.parse("库存明细和单据明细不一致，请检查，单据编号：" + orderNo);
        }

        // 获取库位
        LocMast locMast = locMastService.selectById(locNo);
        // 获取路径
        int ioType = 101;
        StaDesc staDesc = staDescService.queryCrnStnAuto(ioType, locMast.getCrnNo(), outSite);
        // 生成工作号
        int workNo = commonService.getWorkNo(WorkNoType.getWorkNoType(ioType));
        // 生成工作档
        WrkMast wrkMast = new WrkMast();
        wrkMast.setWrkNo(workNo);
        wrkMast.setInvWh(param.getEndLocation()); // 地码
        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(locNo); // 源库位
        wrkMast.setFullPlt("Y"); // 满板：Y
        wrkMast.setPicking("N"); // 拣料
        wrkMast.setExitMk("N"); // 退出
        wrkMast.setEmptyMk("N"); // 空板
        wrkMast.setLinkMis("N");
        wrkMast.setBarcode(barcode);
        wrkMast.setAppeTime(now);
        wrkMast.setModiTime(now);
        if (!wrkMastService.insert(wrkMast)) {
            throw new CoolException("保存工作档失败，出库库位号：" + locNo);
        }

        // 生成工作档明细
        for (OrderDetl orderDetl : orderDetlList) {

            WrkDetl wrkDetl = new WrkDetl();
            wrkDetl.setWrkNo(workNo);
            wrkDetl.sync(orderDetl);
            wrkDetl.setZpallet(wrkMast.getBarcode());
            wrkDetl.setIoTime(now);
            wrkDetl.setOrderNo(orderNo);
            wrkDetl.setAppeTime(now);
            wrkDetl.setModiTime(now);
            if (!wrkDetlService.insert(wrkDetl)) {
                throw new CoolException("保存工作档明细失败");
            }
            // 修改订单明细
            if (!orderDetlService.increaseWorkQty(orderDetl, orderDetl.getAnfme())) {
                throw new CoolException("修改订单明细数量失败");
            }
        }
        // 修改订单状态
        orderService.updateSettle(order.getId(), 2L, null);
        // 修改库位状态:   F.在库 ====>>> R.出库预约/P.拣料/盘点/并板出库中
        if (locMast.getLocSts().equals("F")) {
            locMast.setLocSts("R");
            locMast.setModiTime(now);
            if (!locMastService.updateById(locMast)) {
                throw new CoolException("预约库位状态失败，库位号：" + locNo);
            }
        } else {
            throw new CoolException(locNo + "库位不是在库状态");
        }
        return R.ok("出库成功");
    }



    @Override
    @Transactional
@@ -440,12 +706,12 @@
    @Override
    @Transactional
    public void syncMat(MatSyncParam param) {
        if (Cools.isEmpty(param.getMatDetails()) || param.getMatDetails().size() <=0 ) {
        if (Cools.isEmpty(param.getMatDetails()) || param.getMatDetails().size() <= 0) {
            throw new CoolException("商品数据为空");
        }

        for(MatSyncParam.MatParam matParam : param.getMatDetails()){
            if(Cools.isEmpty(matParam.getMatnr())){
        for (MatSyncParam.MatParam matParam : param.getMatDetails()) {
            if (Cools.isEmpty(matParam.getMatnr())) {
                throw new CoolException("商品编码不能为空");
            }

@@ -538,7 +804,7 @@
                }
            } else {
                mat.sync(param);
                if (!matService.update(mat, new EntityWrapper<Mat>().eq("matnr",matParam.getMatnr()))) {
                if (!matService.update(mat, new EntityWrapper<Mat>().eq("matnr", matParam.getMatnr()))) {
                    throw new CoolException("更新已存在商品信息失败，请联系管理员");
                }
            }