盘点异常处理

pang.jiabao

2024-09-19 80cd1569120416b096d28ebbe9a8e6e1d867f6e0

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

@@ -2,7 +2,6 @@

import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.core.common.Cools;
import com.core.common.DateUtils;
import com.core.common.R;
@@ -14,6 +13,8 @@
import com.zy.asrs.entity.result.StockVo;
import com.zy.asrs.entity.result.ZphjcdgzVo;
import com.zy.asrs.entity.result.ZphjcdwcVo;
import com.zy.asrs.mapper.LocDetlMapper;
import com.zy.asrs.mapper.MatMapper;
import com.zy.asrs.mapper.TagMapper;
import com.zy.asrs.service.*;
import com.zy.asrs.utils.MatUtils;
@@ -30,6 +31,7 @@
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.*;
import java.util.stream.Collectors;

@@ -39,6 +41,14 @@
@Slf4j
@Service
public class OpenServiceImpl implements OpenService {

    // 二楼堆垛机对应入库站点
    private static final int[] secondFloorIn = new int[]{0,2061,2064,2067,2070,2073,2076};
    // 堆垛机对应一楼出库站点
    private static final int[] secondFloorOut = new int[]{0,3002,3003,3006,3008,3009,3012};
    // 堆垛机对应一楼入库站点
    private static final int[] oneFloorIn = new int[]{0,3001,3004,3005,3007,3010,3011};


    @Autowired
    private OrderService orderService;
@@ -84,6 +94,12 @@
    private LocMastService locMastService;
    @Autowired
    private ApiLogService apiLogService;

    @Resource
    private MatMapper matMapper;

    @Resource
    private LocDetlMapper locDetlMapper;

    @Override
    @Transactional
@@ -986,6 +1002,209 @@
    }

    @Override
    public void updateBarcode() {
        List<LocMast> locMasts = locMastService.selectList(new EntityWrapper<LocMast>().eq("loc_sts", "D"));
        for (int i = 0; i < locMasts.size(); i ++) {
            LocMast locMast = locMasts.get(i);
            locMast.setBarcode("a"+i);
            locMastService.updateById(locMast);
        }
        System.out.println("更新完了" + locMasts.size());
    }

    @Override
    @Transactional
    public void prodCheck(List<ProdCheckParam> param) {
        if (param.isEmpty()) {
            throw new CoolException("请求参数不能为空");
        }
        for (ProdCheckParam checkParam : param) {
            // 更新库存明细是否合格
            LocDetl locDetl = locDetlService.selectOne(new EntityWrapper<LocDetl>().eq("brand", checkParam.getPackageGroupNo())
                    .eq("unit", checkParam.getBoxNo()).eq("model", checkParam.getRollNo()));
            // 更新商品表是否合格
            Mat mat = matService.selectOne(new EntityWrapper<Mat>().eq("brand", checkParam.getPackageGroupNo())
                    .eq("unit", checkParam.getBoxNo()).eq("model", checkParam.getRollNo()));
            if (locDetl == null || mat == null) {
                throw new CoolException("更新是否合格物料不存在：" + checkParam);
            }

            locDetl.setThreeCode(checkParam.getQualified());
            mat.setThreeCode(checkParam.getQualified());

            locDetlService.update(locDetl,new EntityWrapper<LocDetl>().eq("brand", checkParam.getPackageGroupNo())
                    .eq("unit", checkParam.getBoxNo()).eq("model", checkParam.getRollNo()));
            matService.update(mat,(new EntityWrapper<Mat>().eq("brand", checkParam.getPackageGroupNo())
                    .eq("unit", checkParam.getBoxNo()).eq("model", checkParam.getRollNo())));
        }
    }

    @Override
    @Transactional
    public String fxprk(FxprkParam param) {

        // 根据包装组号获取到木箱卷信息
        List<Mat> list = matService.selectList(new EntityWrapper<Mat>().in("brand", param.getBoxList().stream().map(FxprkParam.Box::getPackageGroupNo).collect(Collectors.toList())));
        if (list.isEmpty()) {
            throw new CoolException("没有查询到该包装组号信息：" + param.getBoxList().toString());
        }

        LocTypeDto locTypeDto = new LocTypeDto();
        locTypeDto.setLocType1((short) 1);
        StartupDto dto = commonService.getLocNo(1, param.getPalletizingNo(), locTypeDto, 0);

        // 返回GWCS目标信息
        pushStaNoToGwcs(param.getPalletizingNo(), dto.getStaNo(), dto.getWorkNo(), param.getBarcode(),"一楼反修品入库推送gwcs");
//        if (!result) {
//            throw new CoolException("入库回推入库码头给GWCS失败");
//        }

        int workNo = dto.getWorkNo();
        Date now = new Date();
        // 生成工作档
        WrkMast wrkMast = new WrkMast();
        wrkMast.setWrkNo(workNo);
        wrkMast.setIoTime(new Date());
        wrkMast.setWrkSts(1L); // 工作状态：设备上走
        wrkMast.setIoType(1); // 入出库状态：1.入库
        wrkMast.setIoPri(13D); // 优先级
        wrkMast.setCrnNo(dto.getCrnNo());
        wrkMast.setSourceStaNo(param.getPalletizingNo());
        wrkMast.setStaNo(dto.getStaNo());
        wrkMast.setLocNo(dto.getLocNo());
        wrkMast.setBarcode(param.getBarcode()); // 托盘码
        wrkMast.setFullPlt("Y"); // 满板：Y
        wrkMast.setPicking("N"); // 拣料
        wrkMast.setExitMk("N"); // 退出
        wrkMast.setEmptyMk("N"); // 空板
        wrkMast.setLinkMis("Y");
        wrkMast.setCtnType(1); // 容器类型
        // 操作人员数据
        wrkMast.setAppeTime(now);
        wrkMast.setModiTime(now);
        boolean res = wrkMastService.insert(wrkMast);
        if (!res) {
            throw new CoolException("保存工作档失败");
        }

        for (Mat obj : list) {
            WrkDetl wrkDetl = new WrkDetl();
            wrkDetl.sync(obj);
            wrkDetl.setWrkNo(wrkMast.getWrkNo());
            wrkDetl.setAnfme(1.0);
            // 重新定位木箱位置
            for (FxprkParam.Box box :param.getBoxList()) {
                if (box.getPackageGroupNo().equals(obj.getBrand())) {
                    if (!box.getBoxPos().equals(obj.getOrigin())) {
                        wrkDetl.setOrigin(box.getBoxPos());
                        wrkDetl.setZpallet(param.getBarcode());
                        wrkDetl.setBarcode(param.getBarcode());
                        matMapper.updateBoxPos(box.getPackageGroupNo(), box.getBoxPos(),param.getBarcode());
                    }
                    break;
                }
            }
            wrkDetl.setIoTime(now);
            wrkDetl.setAppeTime(now);
            wrkDetl.setModiTime(now);
            if (!wrkDetlService.insert(wrkDetl)) {
                throw new CoolException("保存工作明细失败");
            }
        }

        // 更新目标库位状态
        LocMast locMast = locMastService.selectById(dto.getLocNo());
        if (locMast.getLocSts().equals("O")) {
            locMast.setLocSts("S"); // S.入库预约
            locMast.setModiTime(now);
            if (!locMastService.updateById(locMast)) {
                throw new CoolException("改变库位状态失败");
            }
        } else {
            throw new CoolException(dto.getLocNo() + "目标库位已被占用");
        }
        return "入库成功";
    }

    @Override
    @Transactional
    public R kthl(KthlParam param) {

        // 获取模式为电脑模式，无任务的堆垛机列表:防止分配到堆垛机不可用
        List<BasCrnp> basCrnps = basCrnpService.selectList(new EntityWrapper<BasCrnp>().eq("crn_sts",3)
                .eq("wrk_no",0).eq("in_enable","Y").eq("out_enable","Y"));
        if (basCrnps.isEmpty()) {
            // 都有任务则获取电脑模式的堆垛机列表
            basCrnps = basCrnpService.selectList(new EntityWrapper<BasCrnp>().eq("crn_sts",3).eq("in_enable","Y")
                    .eq("out_enable","Y"));
        }
        if (basCrnps.isEmpty()) {
            throw new CoolException("没有可用堆垛机,堆垛机停止或异常或禁用");
        }
        // 可用堆垛机列表
        List<Integer> crnNoList = basCrnps.stream().map(BasCrnp::getCrnNo).collect(Collectors.toList());
        Integer crnNo = crnNoList.get(0);

        int workNo = commonService.getWorkNo(5);
        Date now = new Date();
        // 生成工作档
        WrkMast wrkMast = new WrkMast();
        wrkMast.setWrkNo(workNo);
        wrkMast.setIoTime(new Date());
        wrkMast.setWrkSts(1L); //
        wrkMast.setIoType(3); // 站到站
        wrkMast.setIoPri(14D); // 优先级
        wrkMast.setCrnNo(crnNo);
        wrkMast.setSourceStaNo(secondFloorIn[crnNo]);
        wrkMast.setStaNo(secondFloorOut[crnNo]);
        wrkMast.setLocNo("");
        wrkMast.setBarcode(param.getBarcode()); // 托盘码
        wrkMast.setFullPlt("N"); // 满板：Y
        wrkMast.setPicking("N"); // 拣料
        wrkMast.setExitMk("N"); // 退出
        wrkMast.setEmptyMk("Y"); // 空板
        wrkMast.setLinkMis("Y");
        wrkMast.setCtnType(1); // 容器类型
        // 操作人员数据
        wrkMast.setAppeTime(now);
        wrkMast.setModiTime(now);
        boolean res = wrkMastService.insert(wrkMast);
        if (!res) {
            throw new CoolException("保存工作档失败");
        }
        // 返回GWCS目标信息
        pushStaNoToGwcs(param.getPalletizingNo(),wrkMast.getSourceStaNo(),workNo,param.getBarcode(),"二楼空托回流推送gwcs");

        return R.ok("空托回流请求成功");
    }

    @Override
    public R tb(TbParam param) {
        List<WrkDetl> wrkDetls = wrkDetlService.selectList(new EntityWrapper<WrkDetl>().eq("barcode", param.getBarcode()));
        if (wrkDetls.isEmpty()) {
            return R.parse("无物料明细信息");
        }
        List<String> collect = wrkDetls.stream().map(WrkDetl::getUnit).distinct().collect(Collectors.toList());
        return R.ok(collect);
    }

    @Override
    public R dd(TbParam param) {
        List<WrkDetl> wrkDetls = wrkDetlService.selectList(new EntityWrapper<WrkDetl>().eq("barcode", param.getBarcode()));
        if (wrkDetls.isEmpty()) {
            return R.parse("无物料明细信息");
        }
        List<DdParam> collect = wrkDetls.stream().map(wrkDetl -> {
            DdParam ddParam = new DdParam();
            ddParam.setBoxPos(wrkDetl.getOrigin());
            ddParam.setBoxType(wrkDetl.getColor());
            return ddParam;
        }).distinct().collect(Collectors.toList());

        return R.ok(collect);
    }

    @Override
    @Transactional
    public R gwmsGenerateInventory(GwmsGenerateInventoryDto param) {

@@ -1014,7 +1233,7 @@
        StartupDto dto = commonService.getLocNo(iotype, param.getPalletizingNo(), locTypeDto,0);

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


        int workNo = dto.getWorkNo();
@@ -1051,39 +1270,43 @@
                WrkDetl wrkDetl = new WrkDetl();
                wrkDetl.setWrkNo(wrkMast.getWrkNo());
                obj.getRolls().forEach(roll -> {
//                Mat mat = matService.selectByMatnr(roll.getSpecs());
//                if (mat == null) {
//                    mat = new Mat();
//                    mat.setTagId(6L);
//                    mat.setMatnr(roll.getSpecs());
//                    mat.setMaktx(roll.getSpecs());
//                    mat.setSpecs(roll.getSpecs());
//                    mat.setStatus(1);
//                    mat.setCreateTime(now);
//                    mat.setUpdateTime(now);
//                    if (!matService.insert(mat)) {
//                        throw new CoolException("物料导入失败！");
//                    }
//                }
                    wrkDetl.setWrkNo(wrkMast.getWrkNo());
                    wrkDetl.setMatnr(roll.getSpecs()); // 规格
                    wrkDetl.setMaktx(roll.getSpecs()); //规格
                    wrkDetl.setBatch(roll.getBoxNo()); // 箱号
                    wrkDetl.setUnit(roll.getBoxNo()); // 箱号
                    wrkDetl.setModel(roll.getRollNo()); // 卷号
                    wrkDetl.setBrand(obj.getPackageGroupNo()); // 包装组号
                    wrkDetl.setZpallet(param.getBarcode()); // 托盘吗
                    wrkDetl.setZpallet(param.getBarcode()); // 托盘码
                    wrkDetl.setBarcode(param.getBarcode());
                    wrkDetl.setOrigin(obj.getBoxPos()); // 木箱在托盘位置
                    wrkDetl.setColor(obj.getBoxType()); // 木箱类型
                    wrkDetl.setManu(obj.getRollType()); // 管芯类型
                    wrkDetl.setSku(obj.getWideInWidth()); // 实测宽幅
                    wrkDetl.setItemNum(obj.getThickness()); // 生箔厚度
                    wrkDetl.setManuDate(roll.getFqTime()); // 分切下料时间
                    wrkDetl.setWeight(roll.getNetWeight()); // 净重
                    wrkDetl.setVolume(roll.getGrossWeight()); // 毛重
                    wrkDetl.setPrice(roll.getLength());
                    wrkDetl.setSpecs(String.valueOf(roll.getSplices()));
                    wrkDetl.setLength(roll.getLength()); // 长度
                    wrkDetl.setSpecs(String.valueOf(roll.getSplices())); // 接头
                    wrkDetl.setAnfme(1.0);
//                    wrkDetl.setThreeCode(null); // 通过mes或excel导入检测是否合格 0不合格，1 合格
                    wrkDetl.setIoTime(now);
                    wrkDetl.setAppeTime(now);
                    wrkDetl.setModiTime(now);
                    if (!wrkDetlService.insert(wrkDetl)) {
                        throw new CoolException("保存工作明细失败");
                    }

                    // 物料表备份一份
                    Mat mat = new Mat();
                    mat.sync(wrkDetl);
                    mat.setTagId(6L);
                    mat.setCreateTime(now);
                    mat.setUpdateTime(now);
                    if (!matService.insert(mat)) {
                        throw new CoolException("备份物料表失败");
                    }

                });
            }
        }
@@ -1116,6 +1339,9 @@
        }

        wrkMast.setWrkSts(2L);
        if(wrkMast.getIoType() == 10){
            wrkMast.setBarcode(param.getBarcode());
        }
        wrkMastService.updateById(wrkMast);

        return "请求成功";
@@ -1123,7 +1349,7 @@

    @Override
    @Transactional
    public String zwmsOutLocWork(ZwmsOutLocWorkDto param) {
    public R zwmsOutLocWork(ZwmsOutLocWorkDto param) {

        Order order = orderService.selectByNo(param.getOrderNo());
        if (!Cools.isEmpty(order)) {
@@ -1132,6 +1358,7 @@

        DocType docType = docTypeService.selectOrAdd(param.getOrderType(), Boolean.FALSE);
        Date now = new Date();

        // 单据主档
        order = new Order(
                String.valueOf(snowflakeIdWorker.nextId()),    // 编号[非空]
@@ -1169,38 +1396,16 @@
                now,    // 修改时间
                null    // 备注
        );

        if (!orderService.insert(order)) {
            throw new CoolException("生成单据主档失败，请联系管理员");
        }

        // 单据明细档
        List<DetlDto> list = new ArrayList<>();
        List<ZwmsOutLocWorkDto.Rolls> orderDetails = param.getMatDetails();
        for (ZwmsOutLocWorkDto.Rolls detail : orderDetails) {
            DetlDto dto = new DetlDto(detail.getRollNo(), detail.getBoxNo(), 1.0);
            dto.setOrderNo(detail.getSpecs());
            dto.setSplices(detail.getSplices());
            if (DetlDto.has(list, dto)) {
                DetlDto detlDto = DetlDto.find(list, dto.getMatnr(), dto.getBatch());
                assert detlDto != null;
                detlDto.setAnfme(detlDto.getAnfme() + 1);
            } else {
                list.add(dto);
            }
        }
        for (DetlDto detlDto : list) {
//            Mat mat = matService.selectByMatnr(detlDto.getMatnr());
        for (String groupNo : param.getGroups()) {
            OrderDetl orderDetl = new OrderDetl();
//            if (Cools.isEmpty(mat)) {
//                throw new CoolException(detlDto.getMatnr() + "编号商品检索失败，请先添加商品");
//            } else {
//                orderDetl.sync(mat);
//            }
            orderDetl.setSpecs(String.valueOf(detlDto.getSplices()));
            orderDetl.setBatch(detlDto.getBatch() == null ? "" : detlDto.getBatch());
            orderDetl.setModel(detlDto.getMatnr());
            orderDetl.setMatnr(detlDto.getOrderNo());
            orderDetl.setMaktx(detlDto.getOrderNo());
            orderDetl.setAnfme(detlDto.getAnfme());
            orderDetl.setBrand(groupNo);
            orderDetl.setBatch("");
            orderDetl.setOrderId(order.getId());
            orderDetl.setOrderNo(order.getOrderNo());
            orderDetl.setCreateBy(9527L);
@@ -1209,12 +1414,25 @@
            orderDetl.setUpdateTime(now);
            orderDetl.setStatus(1);
            orderDetl.setQty(0.0D);
            orderDetl.setAnfme(1.0);
            if (!orderDetlService.insert(orderDetl)) {
                throw new CoolException("生成单据明细失败，请联系管理员");
            }
        }

        return null;
        return R.ok("单据生成成功");

    }

    @Override
    public R queryInLocTime(List<String> param) {
        if (Cools.isEmpty(param)) {
            return R.parse("参数不能为空");
        }

        List<InLocTimeDto> inLocTimeDtos = locDetlMapper.queryInLocTime(param);

        return R.ok(inLocTimeDtos);
    }

    @Override
@@ -1232,13 +1450,21 @@
            throw new CoolException("工作档当前状态不符合，任务号：" + param.getWorkNo() + "，工作档状态：" + wrkMast.getWrkSts());
        }

        List<WrkDetl> wrkDetls = wrkDetlService.selectList(new EntityWrapper<WrkDetl>().eq("wrk_no", param.getWorkNo()));

        // 是否需要复核(出库单需复核)
        boolean flag = false;
        if (!wrkDetls.isEmpty()) {
            flag = wrkDetls.stream().anyMatch(wrkDetl -> wrkDetl.getOrderNo() != null);
        }

        // 到达出库口确认为1，更新工作档状态为57.出库完成
        if (param.getOutLocResult() == 1) {
            wrkMast.setWrkSts(20L);
            // 空托盘到位直接更新工作档状态为14.已出库未确认，空托无需复核确认
            if (wrkMast.getIoType() == 110) {
//            wrkMast.setWrkSts(20L);
//            // 空托盘到位直接更新工作档状态为14.已出库未确认，空托无需复核确认
//            if (!flag || wrkMast.getIoType() == 110) {
                wrkMast.setWrkSts(14L);
            }
//            }
            wrkMastService.updateById(wrkMast);
        }

@@ -1300,6 +1526,7 @@
        wrkMast.setStaNo(staDesc.getStnNo()); // 目标站
        wrkMast.setCrnNo(locMast.getCrnNo());
        wrkMast.setSourceLocNo(locMast.getLocNo()); // 源库位
        wrkMast.setBarcode(locMast.getBarcode());
        wrkMast.setFullPlt("N"); // 满板：Y
        wrkMast.setPicking("N"); // 拣料
        wrkMast.setExitMk("N"); // 退出
@@ -1346,13 +1573,13 @@

        // 查询要拆的位置，只有一个
        List<WrkDetl> wrkDetls = wrkDetlService.selectList(new EntityWrapper<WrkDetl>().eq("wrk_no", wrkMast.getWrkNo()));
        List<String> collect = wrkDetls.stream().map(WrkDetl::getOrigin).distinct().collect(Collectors.toList());
        String position = collect.get(0);
        WrkDetl wrkDetl = wrkDetls.get(0);

        // 返回拆垛规则
        ZphjcdgzVo zphjcdgzVo = new ZphjcdgzVo();
        zphjcdgzVo.setWorkNo(wrkMast.getWrkNo());
        zphjcdgzVo.setPosition(position);
        zphjcdgzVo.setWorkNo(wrkDetl.getWrkNo());
        zphjcdgzVo.setBoxType(wrkDetl.getColor());
        zphjcdgzVo.setPosition(wrkDetl.getOrigin());

        return R.ok(zphjcdgzVo);
    }
@@ -1361,8 +1588,8 @@
    @Transactional
    public R zphjCdwc(ZphjcdwcParam param) {

        if (Cools.isEmpty(param.getWorkNo())) {
            throw new CoolException("工作号不能为空！");
        if (Cools.isEmpty(param.getWorkNo(),param.getBarcode(),param.getSourceStaNo(),param.getSite())) {
            return R.parse("参数不能为空，请检查入参");
        }
        WrkMast wrkMast = wrkMastService.selectById(param.getWorkNo());
        if (wrkMast == null) {
@@ -1372,60 +1599,59 @@
            throw new CoolException("工作档当前状态不为42/出库类型不为拣料！");
        }

        // 保存工作主档历史档
        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("入库路径不存在");
        }
        // 堆垛机站点(目标站)
        Integer staNo = staDesc.getCrnStn();
        // 更新工作类型103->53
        wrkMast.setIoType(53);
        wrkMast.setWrkSts(52L); // 工作状态42->52.设备上走（拆垛完成）
        // 目标站点源站点转换
        wrkMast.setSourceStaNo(wrkMast.getStaNo());
        wrkMast.setStaNo(staNo);
        // 目标库位=源库位
        wrkMast.setLocNo(wrkMast.getSourceLocNo());
        // 源库位清除
        wrkMast.setSourceLocNo("");
        wrkMast.setModiTime(new Date());

        int outStaNo = 0; // 出库源站点
        if (staNo == 3044 || staNo == 3045) {
             outStaNo = 3046;
        } else if(staNo == 3040 || staNo == 3041) {
             outStaNo = 3042;
        }
        if (outStaNo == 0) {
            throw new CoolException("出库源站点转换有误：" + staNo);
        }

        // 获取出库物料
        List<WrkDetl> wrkDetls = wrkDetlService.selectList(new EntityWrapper<WrkDetl>().eq("wrk_no", wrkMast.getWrkNo()));

        // 创建桁架理货出库的工作档
        int work = create111Work(wrkMast, wrkDetls, param.getSite(), wrkMast.getStaNo(), param.getBarcode());

        int descFlag = getType(wrkDetls);

        // get0原托盘回流信息，get1拆垛出来物料出库信息
        List<ZphjcdwcVo> zphjcdwcVos = new ArrayList<>();
        ZphjcdwcVo zphjcdwcVo1 = new ZphjcdwcVo();
        zphjcdwcVo1.setWorkNo(wrkMast.getWrkNo());
        zphjcdwcVo1.setStaNo(wrkMast.getStaNo());
        zphjcdwcVo1.setSourceStaNo(wrkMast.getSourceStaNo());
        zphjcdwcVo1.setStaNo(wrkMast.getSourceStaNo());
        zphjcdwcVo1.setSourceStaNo(param.getSourceStaNo());
        zphjcdwcVo1.setBarcode(wrkMast.getBarcode());
        zphjcdwcVos.add(zphjcdwcVo1);

        ZphjcdwcVo zphjcdwcVo2 = new ZphjcdwcVo();
        zphjcdwcVo2.setSourceStaNo(outStaNo);
        zphjcdwcVo2.setStaNo(3106); // 3106/3077
        zphjcdwcVo2.setWorkNo(work);
        zphjcdwcVo2.setSourceStaNo(param.getSite());
        zphjcdwcVo2.setStaNo(wrkMast.getStaNo());
        zphjcdwcVo2.setBarcode(param.getBarcode());
        zphjcdwcVo2.setDescFlag(descFlag);
        zphjcdwcVos.add(zphjcdwcVo2);


        // 保存工作主档历史档
        if (!wrkMastLogService.save(wrkMast.getWrkNo())) {
            throw new CoolException("保存工作主档历史档失败");
        }
        // 获取目标站
//        Wrapper<StaDesc> wrapper = new EntityWrapper<StaDesc>()
//                .eq("type_no", wrkMast.getIoType() - 50)
//                .eq("stn_no", wrkMast.getSourceStaNo()) // 作业站点 = 拣料出库的目标站
//                .eq("crn_no", wrkMast.getCrnNo()); // 堆垛机号
//        StaDesc staDesc = staDescService.selectOne(wrapper);
//        if (Cools.isEmpty(staDesc)) {
//            throw new CoolException("入库路径不存在");
//        }
        // 堆垛机站点(目标站)
//        Integer staNo = staDesc.getCrnStn();
        // 更新工作类型103->53
        wrkMast.setIoType(53);
        wrkMast.setWrkSts(52L); // 工作状态42->52.设备上走（拆垛完成）
        // 目标站点源站点转换
        wrkMast.setStaNo(oneFloorIn[wrkMast.getCrnNo()]);
        wrkMast.setSourceStaNo(param.getSourceStaNo());

        // 目标库位=源库位
        wrkMast.setLocNo(wrkMast.getSourceLocNo());
        // 源库位清除
        wrkMast.setSourceLocNo("");
        wrkMast.setModiTime(new Date());

        // 更新工作主档
        wrkMastService.updateById(wrkMast);
@@ -1441,16 +1667,81 @@
        return R.ok(zphjcdwcVos);
    }

    @Override
    public R requestXhd(String barcode) {

        // 库存明细木箱位置集合
        List<LocDetl> locDetls = locDetlMapper.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());

        // 0明细异常,1亮左，2亮右，3都亮
        if (collect1.size() == 0 || collect2.size() == 0){
            return R.ok(0);
        } else if((collect1.size() == 1 && collect2.size() == 1) || (collect1.size() == 2 && collect2.size() == 2)) {
            return R.ok(3);
        } else if(collect1.size() == 2 && collect2.size() == 1) {
            return R.ok(collect2.get(0).equals("左") ? 1 : 2);
        } else {
            return R.parse("亮信号灯条码异常：" + barcode);
        }

    }

    /**
     * 创建桁架理货出库的工作档
     */
    private int create111Work(WrkMast wrk, List<WrkDetl> wrkDetls, Integer site, Integer staNo,String barcode) {
        int workNo = commonService.getWorkNo(4);
        Date now = new Date();
        // 生成工作档
        WrkMast wrkMast = new WrkMast();
        wrkMast.setWrkNo(workNo);
        wrkMast.setIoTime(new Date());
        wrkMast.setWrkSts(2L); // 工作状态：设备上走
        wrkMast.setIoType(111); // 入出库状态：111.理货贴标出库
        wrkMast.setIoPri(13D); // 优先级
        wrkMast.setCrnNo(wrk.getCrnNo());
        wrkMast.setSourceStaNo(site);
        wrkMast.setStaNo(staNo);
        wrkMast.setSourceLocNo(wrk.getSourceLocNo());
        wrkMast.setBarcode(barcode); // 托盘码
        wrkMast.setFullPlt("Y"); // 满板：Y
        wrkMast.setPicking("N"); // 拣料
        wrkMast.setExitMk("N"); // 退出
        wrkMast.setEmptyMk("N"); // 空板
        wrkMast.setLinkMis("Y");
        wrkMast.setCtnType(1); // 容器类型
        // 操作人员数据
        wrkMast.setAppeTime(now);
        wrkMast.setModiTime(now);

        // 插入工作档
        wrkMastService.insert(wrkMast);

        // 插入工作档明细
        for (WrkDetl wrkDetl:wrkDetls) {
            wrkDetl.setWrkNo(workNo);
            wrkDetl.setBarcode(barcode);
            wrkDetl.setZpallet(barcode);
            wrkDetlService.insert(wrkDetl);
        }

        return workNo;
    }

    /**
     * 根据出库物料明细判断是否去贴标(单卷贴标，多卷不贴标)
     * @param wrkDetls 物料明细
     * @return 0.多卷不贴标路径，1.单卷贴标路径
     * @return 1.多卷直接出路径，4.单卷贴标路径
     */
    private int getType(List<WrkDetl> wrkDetls) {
        return wrkDetls.size() > 1 ? 0 : 1; // 一条记录就是一卷
        return wrkDetls.size() > 1 ? 1 : 4; // 一条记录就是一卷
    }

    public void pushStaNoToGwcs(Integer palletizingNo, Integer staNo, Integer workNo) {
    public boolean pushStaNoToGwcs(Integer palletizingNo, Integer staNo, Integer workNo,String barcode,String message) {
        boolean success = false;
        // 获取请求头
        Map<String, Object> headers = getHeaders();
@@ -1460,6 +1751,7 @@
        jsonObject.put("workNo", workNo);
        jsonObject.put("staNo", staNo);
        jsonObject.put("sourceStaNo", palletizingNo);
        jsonObject.put("barcode", barcode);
        String body = jsonObject.toJSONString();
        String response = "";
        try {
@@ -1472,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",
@@ -1500,6 +1785,7 @@
                log.error("", e);
            }
        }
        return success;
    }

    Map<String, Object> getHeaders(){