对接接口开发

dubin

2026-03-18 2a9f6d72baa207bc91c98d0a5cd2235be9816691

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

@@ -1,21 +1,22 @@
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.R;
import com.core.common.SnowflakeIdWorker;
import com.core.common.*;
import com.core.exception.CoolException;
import com.zy.asrs.entity.*;
import com.zy.asrs.entity.param.*;
import com.zy.asrs.entity.result.OpenInventoryVo;
import com.zy.asrs.entity.result.OpenOrderCompeteResult;
import com.zy.asrs.entity.result.OpenSummaryVo;
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.LocDto;
import com.zy.common.model.TaskDto;
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;
@@ -25,6 +26,7 @@
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;

/**
 * Created by vincent on 2022/4/9
@@ -63,6 +65,21 @@

    @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
@@ -163,45 +180,140 @@

    @Override
    @Transactional
    public R outbound(List<LocDto> locDtos) throws InterruptedException {
        if (Cools.isEmpty(locDtos)) {
            return R.parse(BaseRes.PARAM);
    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);
        }
        boolean lack = true;
        for (LocDto locDto : locDtos) {
            if (!locDto.isLack()) {
                lack = false;

        // 库位号
        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 (lack) {
            return R.error("库存不足");
        if (outSite == null) {
            outSite = 123;
        }

        Thread.sleep(1000L);
        Date now = new Date();

        List<TaskDto> taskDtos = new ArrayList<>();
        // 根据 （库位 & 出库站） 分组； 理想状态：一组为一次出库任务
        for (LocDto locDto : locDtos) {
            if (locDto.isLack()) {
                continue;
        // 获取单据
        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("保存工作档明细失败");
            }
            TaskDto taskDto = new TaskDto(locDto.getLocNo(), locDto.getStaNo(), locDto);
            if (TaskDto.has(taskDtos, taskDto)) {
                TaskDto dto = TaskDto.find(taskDtos, taskDto);
                assert dto != null;
                dto.getLocDtos().addAll(taskDto.getLocDtos());
            } else {
                taskDtos.add(taskDto);
            // 修改订单明细
            if (!orderDetlService.increaseWorkQty(orderDetl, orderDetl.getAnfme())) {
                throw new CoolException("修改订单明细数量失败");
            }
        }
        // -----------------------------------------------------------------------------------------------
        for (TaskDto taskDto : taskDtos) {
            BasDevp staNo = basDevpService.checkSiteStatus(taskDto.getStaNo());
            workService.stockOut(staNo, taskDto, null);
        // 修改订单状态
        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
@@ -675,7 +787,7 @@
                } else {
                    tagId = tagService.getTop().getId();
                }
                mat.sync(param);
                mat.sync(matParam);
//            mat.setMatnr(param.getMatnr());
//            mat.setMaktx(param.getMaktx());
//            mat.setSpecs(param.getSpecs());
@@ -691,7 +803,7 @@
                    log.info("同步新物料[商品编号：{}]", mat.getMatnr());
                }
            } else {
                mat.sync(param);
                mat.sync(matParam);
                if (!matService.update(mat, new EntityWrapper<Mat>().eq("matnr",matParam.getMatnr()))) {
                    throw new CoolException("更新已存在商品信息失败，请联系管理员");
                }
@@ -700,4 +812,143 @@

    }

    @Override
    public void orderCreate(OpenOrderParam param) {
        Order order = orderService.selectByNo(param.getOrderNo());
        if (!Cools.isEmpty(order)){
            throw new CoolException(param.getOrderNo() + "订单已存在，请勿重复创建");
        }
        Date now = new Date();
        order = new Order(
                String.valueOf(snowflakeIdWorker.nextId()), // 编号[非空]
                param.getOrderNo(), // 订单编码[非空]
                DateUtils.convert(now), //单据日期
                param.getOrderType(), //订单类型
                null, //项目编号
                null, //项目名称 客户PO号
                null, //调拨项目编号
                null, //初始票据号
                null, //票据号
                null, //客户编号
                null, //客户
                param.getOrderInternalCode(), //单据内码
                param.getWkType(), //业务类型
                null, //合计金额
                null, //优惠率
                null, //优惠金额
                null, //销售或采购费用合计
                null, //实付金额
                null, //付款类型 1: 现金  2: 记账
                null, //业务员
                null, //结算天数
                null, //邮费支付类型 1: 在线支付  2: 货到付款
                null, //邮费
                param.getBusinessTime(), //业务日期
                param.getCreateTime(), //创建日期
                null, //物流名称
                null, //物流单号
                1L, //订单状态
                1, //状态 1: 正常  0: 禁用
                9527L, //添加人员
                now, //添加时间
                9527L, //修改人员
                now, //修改时间
                param.getStationId(), //入/出库接驳站点
                param.getOperateType() // 操作类型 1.新增 2.修改 3.取消
        );
        if (!orderService.insert(order)){
            throw new CoolException("保存订单主档失败,请联系管理员！"+order);
        }
        List<OpenOrderParam.OrderItem> list = new ArrayList<>();
        List<OpenOrderParam.OrderItem> orderItems = param.getOrderItems();
        for (OpenOrderParam.OrderItem item : orderItems){
            OpenOrderParam.OrderItem orderItem = new OpenOrderParam.OrderItem(
                    item.getLineId(),
                    item.getMatNr(),
                    item.getMakTx(),
                    item.getAnfme(),
                    item.getSpec(),
                    item.getModel(),
                    item.getUnit(),
                    item.getBatch(),
                    item.getPalletId(),
                    item.getPlanNo(),
                    item.getTargetWareHouseId(),
                    item.getSourceWareHouseId()
            );
            if (OpenOrderParam.OrderItem.hasLineNumber(list,orderItem)){
                OpenOrderParam.OrderItem oi = OpenOrderParam.OrderItem.findLineNumber(
                        list,
                        item.getLineId(),
                        item.getMatNr(),
                        item.getMakTx(),
                        item.getAnfme(),
                        item.getSpec(),
                        item.getModel(),
                        item.getUnit(),
                        item.getBatch(),
                        item.getPalletId(),
                        item.getPlanNo(),
                        item.getTargetWareHouseId(),
                        item.getSourceWareHouseId()
                );
                assert oi != null;
                oi.setAnfme(oi.getAnfme() + orderItem.getAnfme());
            } else {
                list.add(orderItem);
            }
        }
        for (OpenOrderParam.OrderItem orderItem : list) {
            Mat mat = matService.selectByMatnr(orderItem.getMatNr());
            if (Cools.isEmpty(mat)){
                throw new CoolException("订单明细中的商品编号不存在：" + orderItem.getMatNr());
            }
            OrderDetl orderDetl = new OrderDetl();
            orderDetl.sync(mat);
            orderDetl.setOrderNo(order.getOrderNo()); // 订单编号
            orderDetl.setOrderId(order.getId()); // 订单内码
            orderDetl.setStandby1(order.getTel()); // 行内码 唯一标识
            orderDetl.setAnfme(orderItem.getAnfme()); // 订单数量
            orderDetl.setBarcode(orderItem.getBatch()); // 批次
            orderDetl.setStandby2(orderItem.getPalletId()); // 托盘码
            orderDetl.setStandby3(orderItem.getPlanNo()); // 计划跟踪号
            orderDetl.setBoxType1(orderItem.getSourceWareHouseId()); // 建议入库仓库
            orderDetl.setBoxType2(orderItem.getTargetWareHouseId()); // 建议出库仓库
            orderDetl.setCreateBy(9527L);
            orderDetl.setCreateTime(now);
            orderDetl.setUpdateBy(9527L);
            orderDetl.setUpdateTime(now);
            orderDetl.setStatus(1);
            orderDetl.setQty(0.0D);
    //        orderDetl.setPakinPakoutStatus(1);
            if (!orderDetlService.insert(orderDetl)) {
                throw new CoolException("保存订单明细失败,请联系管理员！"+orderDetl);
            }
        }
    }

    @Override
    public OpenInventoryVo queryInventoryDetails(OpenInventoryParam param) {
        List<LocDetl> locDetlList = locDetlService.queryInventoryDetails(param.getLocId(), param.getMatNr(), param.getOrderNo(), param.getPlanNo(), param.getBatch());
        if (Cools.isEmpty(locDetlList)){
            return new OpenInventoryVo();
        }
        return new OpenInventoryVo(locDetlList);
    }

    @Override
    public OpenSummaryVo queryInventorySummary(OpenSummaryParam param) {
        String matNr = param.getMatNr();
        String[] split = matNr.split(",");
        List<OpenSummaryVo.OpenSummary> openSummaryList = new ArrayList<>();
        for (String s : split) {
            OpenSummaryVo.OpenSummary openSummary = new OpenSummaryVo.OpenSummary();
            Double summary =  locDetlService.queryInventorySummary(param.getWareHouseId(), s);
            openSummary.setWareHouseId(param.getWareHouseId()); // 仓库编码
            openSummary.setMatNr(s); // 物料编码
            openSummary.setAnfme(summary); // 数量
            openSummaryList.add(openSummary);
        }
        return new OpenSummaryVo(openSummaryList);
    }
}