盘点异常处理

pang.jiabao

2024-09-19 80cd1569120416b096d28ebbe9a8e6e1d867f6e0

盘点异常处理

 src/main/java/com/zy/asrs/controller/MobileController.java

@@ -563,15 +563,11 @@
        return mobileService.pdckqr(param);
    }

//    @PostMapping("/pdtz/auth")
//    @ManagerAuth(memo = "盘点调整库存")
//    public synchronized R pdtz(@RequestBody PdckqrParam param) {
//        // 根据工作号确认复核
//        if(Cools.isEmpty(param) || Cools.isEmpty(param.getBarcode()) ||  Cools.isEmpty(param.getMaterials())){
//            return R.parse(BaseRes.PARAM);
//        }
//        return mobileService.pdtz(param);
//    }
    @PostMapping("/pdtz/auth")
    @ManagerAuth(memo = "盘点异常按实物调整库存信息")
    public synchronized R pdtz(@RequestBody PdtzParam param) {
        return mobileService.pdtz(param);
    }

    @PostMapping("/pdaWarehousingNow")
    @ManagerAuth(memo = "pda组托立即入库")

 src/main/java/com/zy/asrs/entity/param/PdtzParam.java

New file
@@ -0,0 +1,43 @@
package com.zy.asrs.entity.param;

import lombok.Data;

import java.util.List;

/**
 * @author pang.jiabao
 * @description 盘点异常调整库存dto
 * @createDate 2024/9/12 14:53
 */
@Data
public class PdtzParam {

    private String barcode;//    托盘码
    private Integer palletizingNo;// 码垛位编号
    private List<PdtzParam.MatList> matList; // 木箱集合

    @Data
    public static class MatList {
        // 冗余参数，给mes推时和入库时结构保持一致
        private String barcode;//    托盘码
        private Integer palletizingNo;// 码垛位编号

        private String boxPos; // 箱子位置，不填，获取任务的位置

        private String packageGroupNo; // 包装组号
        private String boxType; // 木箱类型
        private String rollType; // 管芯类型
        private String wideInWidth; // 实测宽幅 按规格解析
        private String thickness; // 生箔厚度 按规格解析

        private String rollNo; // 卷号
        private String boxNo; // 箱号
        private String specs; //规格
        private Double length; //长度
        private Integer splices; //接头 个
        private Double netWeight; // 净重
        private Double grossWeight; // 毛重
        private String fqTime; // 分切下料时间
    }

}

 src/main/java/com/zy/asrs/mapper/OrderDetlMapper.java

@@ -43,4 +43,9 @@
    void updateOrderDetlByGroupNo(@Param("orderNo") String orderNo,@Param("brand") String brand, @Param("count") double count);

    void updateOrderDetlQtyByGroupNo(@Param("orderNo") String orderNo,@Param("brand") String brand);

    /**
     * 按包装组号标记盘点记录异常
     */
    void updateCheckExceptionByGroup(@Param("groups") List<String> groups);
}

 src/main/java/com/zy/asrs/service/MobileService.java

@@ -66,4 +66,9 @@
     * pda反修品入库
     */
    R pdaFxprk(FxprkParam param, Long userId);

    /**
     * 盘点异常按实物调整库存信息
     */
    R pdtz(PdtzParam param);
}

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

@@ -10,6 +10,7 @@
import com.zy.asrs.entity.param.*;
import com.zy.asrs.mapper.ManLocDetlMapper;
import com.zy.asrs.mapper.MatMapper;
import com.zy.asrs.mapper.OrderDetlMapper;
import com.zy.asrs.service.*;
import com.zy.asrs.utils.MatUtils;
import com.zy.common.constant.MesConstant;
@@ -92,6 +93,9 @@

    @Resource
    private OpenServiceImpl openServiceImpl;

    @Resource
    private OrderDetlMapper orderDetlMapper;

    @Override
    @Transactional
@@ -1203,7 +1207,7 @@
            throw new CoolException("工作档不存在：" + param.getBarcode());
        }
        if (wrkMast.getIoType() != 107 || wrkMast.getWrkSts() != 2) {
            throw new CoolException(wrkMast.getWrkNo() + ",工作档类型：" + wrkMast.getIoType() + "工作状态：" + wrkMast.getWrkSts() + ",不匹配");
            throw new CoolException(wrkMast.getWrkNo() + "：工作状态不匹配");
        }

        List<WrkDetl> wrkDetls = wrkDetlService.selectByWrkNo(wrkMast.getWrkNo());
@@ -1249,7 +1253,7 @@
            }

            // 推送给gwcs执行命令
            openServiceImpl.pushStaNoToGwcs(wrkMast.getSourceStaNo(),wrkMast.getStaNo(),wrkMast.getWrkNo(),wrkMast.getBarcode());
            openServiceImpl.pushStaNoToGwcs(wrkMast.getSourceStaNo(),wrkMast.getStaNo(),wrkMast.getWrkNo(),wrkMast.getBarcode(),"盘点确认成功推送gwcs");

            return R.ok("盘点确认成功");

@@ -1425,7 +1429,7 @@
        }

        // 推送GWCS目标消息
        openServiceImpl.pushStaNoToGwcs(sourceStaNo,dto.getStaNo(),dto.getWorkNo(),barcode);
        openServiceImpl.pushStaNoToGwcs(sourceStaNo,dto.getStaNo(),dto.getWorkNo(),barcode,"pda组托立即入库推送gwcs");
        return R.ok("入库启动成功");
    }

@@ -1511,12 +1515,340 @@
        }

        // 返回GWCS目标信息
        boolean result = pushStaNoToGwcs(param.getPalletizingNo(), dto.getStaNo(), dto.getWorkNo(), param.getBarcode());
        openServiceImpl.pushStaNoToGwcs(param.getPalletizingNo(), dto.getStaNo(), dto.getWorkNo(), param.getBarcode(),"二楼返修入库推送gwcs");

        // 一楼反修品入库的木箱通过包装组号需给mes推送待判
        pushDpToMes(groupNos);

        return R.ok("入库成功");
    }

    @Override
    @Transactional
    public R pdtz(PdtzParam param) {

        String barcode = param.getBarcode();
        Integer palletizingNo = param.getPalletizingNo();
        List<PdtzParam.MatList> matList = param.getMatList();
        // 增加冗余字段，给mes推送时结构和入库保存一致
        for (PdtzParam.MatList matList1 : matList) {
            matList1.setBarcode(barcode);
            matList1.setPalletizingNo(palletizingNo);
        }

        WrkMast wrkMast = wrkMastService.selectOne(new EntityWrapper<WrkMast>().eq("barcode", barcode));
        LocMast locMast = locMastService.selectById(wrkMast.getSourceLocNo());

        // 实物包装组号
        List<String> groups = matList.stream().map(PdtzParam.MatList::getPackageGroupNo).distinct().collect(Collectors.toList());

        // 库存明细木箱位置集合
        List<LocDetl> locDetls = locDetlService.selectList(new EntityWrapper<LocDetl>().eq("zpallet", barcode));
        List<String> collect1 = locDetls.stream().map(LocDetl::getOrigin).distinct().collect(Collectors.toList());
        // 工作明细木箱位置集合
        List<WrkDetl> wrkDetls = wrkDetlService.selectList(new EntityWrapper<WrkDetl>().eq("zpallet", barcode));
        List<String> collect2 = wrkDetls.stream().map(WrkDetl::getOrigin).distinct().collect(Collectors.toList());
        // 工作的包装组号
        List<String> wrkBrandlist = wrkDetls.stream().map(WrkDetl::getBrand).distinct().collect(Collectors.toList());
        // 工作订单明细
        List<OrderDetl> orderDetlList = orderDetlMapper.selectList(new EntityWrapper<OrderDetl>().in("brand", wrkBrandlist));

        Date now = new Date();

        // 判断要调整的木箱所在位置关系
        if (collect1.size() == 0 || collect2.size() == 0){
            return R.parse(barcode+"：任务库存异常！");
        } else if(collect1.size() == 2 && collect2.size() == 1) { // 2出1，都是单箱的
            if (matList.size() == 0) { // 实物是空
                // 把该任务在库明细删除
                locDetlService.delete(new EntityWrapper<LocDetl>().in("brand",wrkBrandlist));
                // todo 标记异常，推送mes，回库
                for(OrderDetl orderDetl:orderDetlList) {
                    orderDetl.setSource(1);
                    orderDetlMapper.updateById(orderDetl);
                }
                JSONObject jsonObject = new JSONObject();
                jsonObject.put("delete",wrkBrandlist);
                kctzPushMes(jsonObject);
                kctzReturn(wrkMast);
            } else { // 实物不为空
               // 寻找实物的位置
                List<LocDetl> locDetls1 = locDetlService.selectList(new EntityWrapper<LocDetl>().in("brand", groups).notIn("barcode",barcode));
                if (locDetls1.size() == 0) { // 实物无库存
                    // 把该任务在库明细删除
                    locDetlService.delete(new EntityWrapper<LocDetl>().in("brand",wrkBrandlist));
                    // 补充木箱位置
                    matList.get(0).setBoxPos(collect2.get(0));
                    // 把实物物料信息放入任务所在库位
                    insertLocDetl(locMast.getLocNo(),barcode,matList);
                    // todo 标记异常，推送mes，回库
                    for(OrderDetl orderDetl:orderDetlList) {
                        orderDetl.setSource(1);
                        orderDetlMapper.updateById(orderDetl);
                    }
                    JSONObject jsonObject = new JSONObject();
                    jsonObject.put("delete",wrkBrandlist);
                    jsonObject.put("insert",matList);
                    kctzPushMes(jsonObject);
                    kctzReturn(wrkMast);
                }else { // 实物有库存
                    List<String> brandList = locDetls1.stream().map(LocDetl::getBrand).distinct().collect(Collectors.toList());
                    return R.parse(brandList+"库存已存在，请先处理！");
                }
            }
        } else if(collect1.size() == 1 && collect2.size() == 1) {
            if (matList.size() == 0) { // 实物为空
                // 把该任务在库明细删除
                locDetlService.delete(new EntityWrapper<LocDetl>().in("brand",wrkBrandlist));
                // 完成这条盘点任务：更新订单完成数量，工作主档5
                for(WrkDetl wrkDetl:wrkDetls) {
                    if (!Cools.isEmpty(wrkDetl.getOrderNo())) {
                        // 更新订单完成数量
                        orderDetlMapper.updateOrderDetlQtyByGroupNo(wrkDetl.getOrderNo(), wrkDetl.getBrand());
                    }
                }
                if (locMast.getLocSts().equals("P")) {
                    locMast.setLocSts("O");
                    locMast.setBarcode("");
                    locMast.setSheetNo("");
                    locMast.setIoTime(now);
                    locMast.setModiTime(now);
                    locMastService.updateById(locMast);
                }
                // 修改工作主档状态
                wrkMast.setWrkSts(5L);
                wrkMast.setModiTime(now);
                wrkMastService.updateById(wrkMast);

                // todo 标记异常，不回库，给gwcs下发去叠盘机命令,推送mes
                for(OrderDetl orderDetl:orderDetlList) {
                    orderDetl.setSource(1);
                    orderDetlMapper.updateById(orderDetl);
                }

                JSONObject jsonObject = new JSONObject();
                jsonObject.put("delete",wrkBrandlist);
                kctzPushMes(jsonObject);

                // 推送给gwcs执行命令
                openServiceImpl.pushStaNoToGwcs(wrkMast.getSourceStaNo(),3013,wrkMast.getWrkNo(),wrkMast.getBarcode(),"盘点异常调整后回叠盘机推送gwcs");
            } else { // 实物不为空
                // 寻找实物的位置
                List<LocDetl> locDetls1 = locDetlService.selectList(new EntityWrapper<LocDetl>().in("brand", groups).notIn("barcode",barcode));
                if (locDetls1.size() == 0) { // 实物无库存
                    // 把该任务在库明细删除
                    locDetlService.delete(new EntityWrapper<LocDetl>().in("brand",wrkBrandlist));
                    // 补充木箱位置
                    for (PdtzParam.MatList matList1:matList) {
                        matList1.setBoxPos(collect2.get(0));
                    }
                    // 把实物物料信息放入任务所在库位
                    insertLocDetl(locMast.getLocNo(),barcode,matList);
                    // todo 标记异常，回库，推送mes
                    for(OrderDetl orderDetl:orderDetlList) {
                        orderDetl.setSource(1);
                        orderDetlMapper.updateById(orderDetl);
                    }

                    JSONObject jsonObject = new JSONObject();
                    jsonObject.put("delete",wrkBrandlist);
                    jsonObject.put("insert",matList);
                    kctzPushMes(jsonObject);

                    kctzReturn(wrkMast);
                } else { // 实物有库存
                    List<String> brandList = locDetls1.stream().map(LocDetl::getBrand).distinct().collect(Collectors.toList());
                    return R.parse(brandList+"库存已存在，请先处理！");
                }
            }
        }  else if (collect1.size() == 2 && collect2.size() == 2) {
            if (matList.size() == 0) { // 实物为空
                // 把该任务在库明细删除
                locDetlService.delete(new EntityWrapper<LocDetl>().in("brand",wrkBrandlist));
                // 完成这条盘点任务：更新订单完成数量，工作主档5
                for(WrkDetl wrkDetl:wrkDetls) {
                    if (!Cools.isEmpty(wrkDetl.getOrderNo())) {
                        // 更新订单完成数量
                        orderDetlMapper.updateOrderDetlQtyByGroupNo(wrkDetl.getOrderNo(), wrkDetl.getBrand());
                    }
                }
                if (locMast.getLocSts().equals("P")) {
                    locMast.setLocSts("O");
                    locMast.setBarcode("");
                    locMast.setSheetNo("");
                    locMast.setIoTime(now);
                    locMast.setModiTime(now);
                    locMastService.updateById(locMast);
                }
                // 修改工作主档状态
                wrkMast.setWrkSts(5L);
                wrkMast.setModiTime(now);
                wrkMastService.updateById(wrkMast);

                // todo 标记异常，推送mes,不回库，给gwcs下发去叠盘机命令
                for(OrderDetl orderDetl:orderDetlList) {
                    orderDetl.setSource(1);
                    orderDetlMapper.updateById(orderDetl);
                }
                JSONObject jsonObject = new JSONObject();
                jsonObject.put("delete",wrkBrandlist);
                jsonObject.put("insert",matList);
                kctzPushMes(jsonObject);

                // 推送给gwcs执行命令
                openServiceImpl.pushStaNoToGwcs(wrkMast.getSourceStaNo(),3013,wrkMast.getWrkNo(),wrkMast.getBarcode(),"盘点异常调整后回叠盘机推送gwcs");
            } else { // 实物不为空
                // 寻找实物的位置
                List<LocDetl> locDetls1 = locDetlService.selectList(new EntityWrapper<LocDetl>().in("brand", groups).notIn("barcode",barcode));
                if (locDetls1.size() == 0) { // 实物无库存
                    // 把该任务在库明细删除
                    locDetlService.delete(new EntityWrapper<LocDetl>().in("brand",wrkBrandlist));
                    // 补充木箱位置
                    matList.get(0).setBoxPos("左");
                    matList.get(1).setBoxPos("右");
                    // 把实物物料信息放入任务所在库位
                    insertLocDetl(locMast.getLocNo(),barcode,matList);
                    // todo 标记异常，回库，推送mes
                    for(OrderDetl orderDetl:orderDetlList) {
                        orderDetl.setSource(1);
                        orderDetlMapper.updateById(orderDetl);
                    }

                    JSONObject jsonObject = new JSONObject();
                    jsonObject.put("delete",wrkBrandlist);
                    jsonObject.put("insert",matList);
                    kctzPushMes(jsonObject);

                    kctzReturn(wrkMast);
                } else { // 实物有库存
                    List<String> brandList = locDetls1.stream().map(LocDetl::getBrand).distinct().collect(Collectors.toList());
                    return R.parse(brandList+"库存已存在，请先处理！");
                }
            }
        }

       return R.ok("调整成功");
    }

    // 同步盘点异常调整结果给mes
    void kctzPushMes(JSONObject jsonObject) {
        // 接口请求结果
        boolean success = false;
        // 接口记录空间名称
        String message = "同步盘点异常调整结果给mes";

        // 构造请求体
        String body = jsonObject.toJSONString();
        String response = "";
        try {
            response = new HttpHandler.Builder()
                    .setUri(MesConstant.MES_CC_IP_PORT)
                    .setPath(MesConstant.MES_CC_YCTZ_URL)
                    .setJson(body)
                    .build()
                    .doPost();
            if (!Cools.isEmpty(response)) {
                JSONObject result = JSON.parseObject(response);
                if (result.getInteger("code").equals(200)) {
                    success = true;
                }
            } else {
                log.error(message + "失败！！！url：{}；request：{}；response：{}", MesConstant.MES_CC_IP_PORT + MesConstant.MES_CC_YCTZ_URL, body, response);
            }
        } catch (Exception e) {
            log.error(message + "异常：{}", e);
        } finally {
            try {
                // 保存接口日志
                apiLogService.save(
                        message,
                        MesConstant.MES_CC_IP_PORT + MesConstant.MES_CC_YCTZ_URL,
                        null,
                        "127.0.0.1",
                        body,
                        response,
                        success
                );
            } catch (Exception e) {
                log.error("", e);
            }
        }
    }

    // 盘点异常回库
    @Transactional
    public void kctzReturn(WrkMast wrkMast) {
        if (!wrkMastLogService.save(wrkMast.getWrkNo())) {
            throw new CoolException("保存工作主档历史档失败");
        }
        // 获取目标站
        Wrapper<StaDesc> wrapper = new EntityWrapper<StaDesc>()
                .eq("type_no", wrkMast.getIoType() - 50)
                .eq("stn_no", wrkMast.getStaNo())
                .eq("crn_no", wrkMast.getCrnNo());
        StaDesc staDesc = staDescService.selectOne(wrapper);
        if (Cools.isEmpty(staDesc)) {
            throw new CoolException("入库路径不存在");
        }
        Date now = new Date();
        // 堆垛机站点(目标站)
        Integer staNo = staDesc.getCrnStn();
        // 更新工作档数据状态
        wrkMast.setIoType(wrkMast.getIoType() - 50); // 入出库类型: 103->53,104->54,107->57
        wrkMast.setWrkSts(14L); // 工作状态: 14.已出库未确认
        wrkMast.setSourceStaNo(wrkMast.getStaNo()); // 源站
        wrkMast.setStaNo(staNo); // 目标站
        wrkMast.setLocNo(wrkMast.getSourceLocNo()); // 目标库位 = 出库时的源库位
        wrkMast.setSourceLocNo(""); // 源库位清空
        wrkMast.setModiTime(now);
        if (!wrkMastService.updateById(wrkMast)) {
            throw new CoolException("更新工作档数据状态失败");
        }
        // 修改库位状态 Q.拣料/盘点/并板再入库
        LocMast locMast = locMastService.selectById(wrkMast.getLocNo());
        locMast.setLocSts("Q");
        locMast.setModiTime(now);
        if (!locMastService.updateById(locMast)) {
            throw new CoolException("修改库位状态失败");
        }

        // 推送给gwcs执行命令
        openServiceImpl.pushStaNoToGwcs(wrkMast.getSourceStaNo(),wrkMast.getStaNo(),wrkMast.getWrkNo(),wrkMast.getBarcode(),"盘点异常调整后推送gwcs");
    }

    /**
     * 调整库存明细
     */
    @Transactional
    void insertLocDetl(String locNo, String barcode, List<PdtzParam.MatList> matList) {
        Date now = new Date();
        for (PdtzParam.MatList mat : matList) {
            LocDetl locDetl = new LocDetl();
            locDetl.setBatch("");
            locDetl.setLocNo(locNo);
            locDetl.setMatnr(mat.getSpecs()); // 规格
            locDetl.setMaktx(mat.getSpecs()); //规格
            locDetl.setUnit(mat.getBoxNo()); // 箱号
            locDetl.setModel(mat.getRollNo()); // 卷号
            locDetl.setBrand(mat.getPackageGroupNo()); // 包装组号
            locDetl.setZpallet(barcode); // 托盘码
            locDetl.setBarcode(barcode);
            locDetl.setOrigin(mat.getBoxPos()); // 木箱在托盘位置
            locDetl.setColor(mat.getBoxType()); // 木箱类型
            locDetl.setManu(mat.getRollType()); // 管芯类型
            locDetl.setSku(mat.getWideInWidth()); // 实测宽幅
            locDetl.setItemNum(mat.getThickness()); // 生箔厚度
            locDetl.setManuDate(mat.getFqTime()); // 分切下料时间
            locDetl.setWeight(mat.getNetWeight()); // 净重
            locDetl.setVolume(mat.getGrossWeight()); // 毛重
            locDetl.setLength(mat.getLength()); // 长度
            locDetl.setSpecs(String.valueOf(mat.getSplices())); // 接头
            locDetl.setAnfme(1.0);
//                    wrkDetl.setThreeCode(null); // 通过mes或excel导入检测是否合格 0不合格，1 合格
            locDetl.setAppeTime(now);
            locDetl.setModiTime(now);
            locDetlService.insert(locDetl);
        }
    }

    /**
@@ -1575,67 +1907,6 @@
        }
    }

    public boolean pushStaNoToGwcs(Integer palletizingNo, Integer staNo, Integer workNo,String barcode) {
        boolean success = false;
        // 获取请求头
        Map<String, Object> headers = getHeaders();

        // 构造请求体
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("workNo", workNo);
        jsonObject.put("staNo", staNo);
        jsonObject.put("sourceStaNo", palletizingNo);
        jsonObject.put("barcode", barcode);
        String body = jsonObject.toJSONString();
        String response = "";
        try {
            response = new HttpHandler.Builder()
                    .setUri(MesConstant.GWCS_IP_PORT)
                    .setPath(MesConstant.GWCS_FPKW_URL)
                    .setHeaders(headers)
                    .setJson(body)
                    .build()
                    .doPost();
            if (!Cools.isEmpty(response)) {
                success = true;
//                // 修改订单状态 4.完成 ===>> 6.已上报
//                if (!orderService.updateSettle(order.getId(), 6L, null)) {
//                    throw new CoolException("服务器内部错误，请联系管理员");
//                }
            } else {
                log.error("zmws推送入库码头站点接口失败！！！url：{}；request：{}；response：{}", MesConstant.URL + MesConstant.PAKIN_URL, body, response);
                throw new CoolException("上报mes系统失败");
            }
        } catch (Exception e) {
            log.error("入库请求接口失败：{}", e.getMessage());
//            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
//            return FAIL.setMsg(e.getMessage());
        } finally {
            try {
                // 保存接口日志
                apiLogService.save(
                        "入库",
                        MesConstant.GWCS_IP_PORT + MesConstant.GWCS_FPKW_URL,
                        null,
                        "127.0.0.1",
                        body,
                        response,
                        success
                );
            } catch (Exception e) {
                log.error("", e);
            }
        }
        return success;
    }
    Map<String, Object> getHeaders(){
        Map<String,Object> headers = new HashMap<>();
        headers.put("digi-type","sync ");
        headers.put("digi-protocol","raw");
        headers.put("digi-datakey"," XCommon.ImportData");

        return headers;
    }
    private Map<String, String> getPackageGroupNoByGwms(List<String> boxNoList) {
        Map<String, String> map = null;
        Map<String, Object> headers = new HashMap<>();

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

@@ -1054,7 +1054,7 @@
        StartupDto dto = commonService.getLocNo(1, param.getPalletizingNo(), locTypeDto, 0);

        // 返回GWCS目标信息
        boolean result = pushStaNoToGwcs(param.getPalletizingNo(), dto.getStaNo(), dto.getWorkNo(), param.getBarcode());
        pushStaNoToGwcs(param.getPalletizingNo(), dto.getStaNo(), dto.getWorkNo(), param.getBarcode(),"一楼反修品入库推送gwcs");
//        if (!result) {
//            throw new CoolException("入库回推入库码头给GWCS失败");
//        }
@@ -1173,7 +1173,7 @@
            throw new CoolException("保存工作档失败");
        }
        // 返回GWCS目标信息
        pushStaNoToGwcs(param.getPalletizingNo(),wrkMast.getSourceStaNo(),workNo,param.getBarcode());
        pushStaNoToGwcs(param.getPalletizingNo(),wrkMast.getSourceStaNo(),workNo,param.getBarcode(),"二楼空托回流推送gwcs");

        return R.ok("空托回流请求成功");
    }
@@ -1233,7 +1233,7 @@
        StartupDto dto = commonService.getLocNo(iotype, param.getPalletizingNo(), locTypeDto,0);

        // 返回GWCS目标信息
        pushStaNoToGwcs(param.getPalletizingNo(),dto.getStaNo(),dto.getWorkNo(),param.getBarcode());
        pushStaNoToGwcs(param.getPalletizingNo(),dto.getStaNo(),dto.getWorkNo(),param.getBarcode(),"gwms申请入库后推送gwcs");


        int workNo = dto.getWorkNo();
@@ -1741,7 +1741,7 @@
        return wrkDetls.size() > 1 ? 1 : 4; // 一条记录就是一卷
    }

    public boolean pushStaNoToGwcs(Integer palletizingNo, Integer staNo, Integer workNo,String barcode) {
    public boolean pushStaNoToGwcs(Integer palletizingNo, Integer staNo, Integer workNo,String barcode,String message) {
        boolean success = false;
        // 获取请求头
        Map<String, Object> headers = getHeaders();
@@ -1764,23 +1764,16 @@
                    .doPost();
            if (!Cools.isEmpty(response)) {
                success = true;
//                // 修改订单状态 4.完成 ===>> 6.已上报
//                if (!orderService.updateSettle(order.getId(), 6L, null)) {
//                    throw new CoolException("服务器内部错误，请联系管理员");
//                }
            } else {
                log.error("zmws推送入库码头站点接口失败！！！url：{}；request：{}；response：{}", MesConstant.URL + MesConstant.PAKIN_URL, body, response);
                throw new CoolException("上报mes系统失败");
                log.error(message + "失败！！！url：{}；request：{}；response：{}", MesConstant.URL + MesConstant.PAKIN_URL, body, response);
            }
        } catch (Exception e) {
            log.error("入库请求接口失败：{}", e.getMessage());
//            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
//            return FAIL.setMsg(e.getMessage());
            log.error(message + "异常：{}", e);
        } finally {
            try {
                // 保存接口日志
                apiLogService.save(
                        "入库",
                        message,
                        MesConstant.GWCS_IP_PORT + MesConstant.GWCS_FPKW_URL,
                        null,
                        "127.0.0.1",

 src/main/java/com/zy/common/constant/MesConstant.java

@@ -22,6 +22,9 @@
    // 给仓储MES推送盘点出库结果
    public static final String MES_CC_SB_URL = "/planCutRolling/v1/updateBatchHandleType";

    // 给仓储MES推送盘点异常调整结果
    public static final String MES_CC_YCTZ_URL = "/planCutRolling/v1/exception";

    // MES质量IP地址
    public static final String MES_ZL_IP_PORT = "http://172.22.152.3:8157";


 src/main/resources/mapper/OrderDetlMapper.xml

@@ -231,5 +231,11 @@
        and order_no = #{orderNo}
        and brand = #{brand}
    </update>
    <update id="updateCheckExceptionByGroup">
        update man_order_detl set source = 1 where 1 = 1 and brand in
        <foreach collection="groups" item="item" separator="," open="(" close=")">
            #{item}
        </foreach>
    </update>

</mapper>