盘点异常处理

pang.jiabao

2024-09-19 80cd1569120416b096d28ebbe9a8e6e1d867f6e0

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

@@ -1,7 +1,7 @@
package com.zy.asrs.service.impl;

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;
@@ -11,25 +11,29 @@
import com.zy.asrs.entity.param.*;
import com.zy.asrs.entity.result.OpenOrderCompeteResult;
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;
import com.zy.common.constant.MesConstant;
import com.zy.common.model.DetlDto;
import com.zy.common.model.LocTypeDto;
import com.zy.common.model.StartupDto;
import com.zy.common.model.enums.WorkNoType;
import com.zy.common.service.CommonService;
import com.zy.common.utils.HttpHandler;
import com.zy.common.utils.NodeUtils;
import com.zy.common.web.WcsController;
import com.zy.common.web.param.SearchLocParam;
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 java.util.Date;
import java.util.List;
import javax.annotation.Resource;
import java.util.*;
import java.util.stream.Collectors;

/**
 * Created by vincent on 2022/4/9
@@ -37,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;
@@ -71,6 +83,8 @@
    @Autowired
    private WrkDetlSingleService wrkDetlSingleService;
    @Autowired
    private WrkMastLogService wrkMastLogService;
    @Autowired
    private WrkMastStaService wrkMastStaService;
    @Autowired
    private WrkMastStaLogService wrkMastStaLogService;
@@ -78,6 +92,14 @@
    private StaDescService staDescService;
    @Autowired
    private LocMastService locMastService;
    @Autowired
    private ApiLogService apiLogService;

    @Resource
    private MatMapper matMapper;

    @Resource
    private LocDetlMapper locDetlMapper;

    @Override
    @Transactional
@@ -692,7 +714,7 @@
     * */
    @Override
    @Transactional
    public void palletizingComplete(PalletizingCompleteParam param) {
    public void PalletizingCompleteTwoFloorParam(PalletizingCompleteTwoFloorParam param) {
        Long userId = 7777L;//中控
        //判断param参数
        if (Cools.isEmpty(param.getBarcode())){
@@ -701,36 +723,60 @@
            throw new CoolException("参数：码垛位编号 palletizingNo为空");
        }else if (Cools.isEmpty(param.getBoxType())){
            throw new CoolException("参数：木箱类型 boxType为空");
        }else if (Cools.isEmpty(param.getMatLists()) || param.getMatLists().size()==0){
        }else if (Cools.isEmpty(param.getMatList()) || param.getMatList().size()==0){
            throw new CoolException("参数：物料明细 matLists为空");
        }

        ArrayList<String> positions = new ArrayList<>();   //木箱位置查重      (orgin)
        String matnrOne = "";//木箱相同位置 规格 matnr校验  1、左
        String matnrTwo = "";//木箱相同位置 规格 matnr校验  2、右
        ArrayList<String> boxNos = new ArrayList<>();   //木箱唯一编码查重  （batch）
        //判断matLists参数
        for (PalletizingCompleteParam.MatList matList:param.getMatLists()){
        for (PalletizingCompleteTwoFloorParam.MatList matList:param.getMatList()){
            if (Cools.isEmpty(matList.getMatnr())){
                throw new CoolException("参数：物料编码 matnr为空");
                throw new CoolException("参数：规格 matnr为空");
            }else if (Cools.isEmpty(matList.getPosition())){
                throw new CoolException("物料编码："+matList.getMatnr()+"、参数：码垛位置 position为空");
            }else if (Cools.isEmpty(matList.getBoxNo())){
                throw new CoolException("物料编码："+matList.getMatnr()+"、参数：木箱编号 boxNo为空");
            }else if (Cools.isEmpty(matList.getAnfme()) || matList.getAnfme().equals(0)){
                throw new CoolException("物料编码："+matList.getMatnr()+"、参数：木箱中铜箔数量 anfme为空");
                throw new CoolException("规格："+matList.getMatnr()+"、参数：码垛位置 position为空");
            }else if (Cools.isEmpty(matList.getBatch())){
                throw new CoolException("规格："+matList.getMatnr()+"、参数：木箱编号 batch为空");
            }else if (Cools.isEmpty(matList.getModel())){
                throw new CoolException("规格："+matList.getMatnr()+"、参数：卷号 model为空");
            }else if (Cools.isEmpty(matList.getBatch())){
                throw new CoolException("规格："+matList.getMatnr()+"、参数：木箱编号 boxNo为空");
            }else if (Cools.isEmpty(matList.getWeight()) || matList.getWeight().equals(0D)){
                throw new CoolException("物料编码："+matList.getMatnr()+"、参数：重量 weight为空");
                throw new CoolException("规格："+matList.getMatnr()+"、参数：净重 weight为空");
            }else if (Cools.isEmpty(matList.getRoughWeight()) || matList.getRoughWeight().equals(0D)){
                throw new CoolException("规格："+matList.getMatnr()+"、参数：毛重 roughWeight");
            }else if (Cools.isEmpty(matList.getRollExtent()) || matList.getRollExtent().equals(0D)){
                throw new CoolException("规格："+matList.getMatnr()+"、参数：卷长度 rollExtent");
            }
//            else if (Cools.isEmpty(matList.getJoint()) || matList.getJoint()==0){
//                throw new CoolException("规格："+matList.getMatnr()+"、参数：接头数 joint");
//            }

            if (matList.getPosition().equals("1")){//1、左  2、右
                if (!matnrOne.equals("")){
                    if (!matnrOne.equals(matList.getMatnr())){
                        throw new CoolException("木箱位置："+matList.getPosition()+"存在不同规格卷信息");
                    }
                }else {
                    matnrOne=matList.getMatnr();
                }
            }else if (matList.getPosition().equals("2")){
                if (!matnrTwo.equals("")){
                    if (!matnrTwo.equals(matList.getMatnr())){
                        throw new CoolException("木箱位置："+matList.getPosition()+"存在不同规格卷信息");
                    }
                }else {
                    matnrTwo=matList.getMatnr();
                }
            }else {
                throw new CoolException("参数：木箱编号 boxNo:"+matList.getBatch()+",木箱位置错误："+matList.getPosition());
            }

            if (!positions.contains(matList.getPosition())){
                positions.add(matList.getPosition());
            if (!boxNos.contains(matList.getBatch())){
                boxNos.add(matList.getBatch());
            }else {
                throw new CoolException("参数：木箱编号 boxNo:"+matList.getBoxNo()+",木箱位置存在重复："+matList.getPosition());
            }

            if (!boxNos.contains(matList.getBoxNo())){
                boxNos.add(matList.getBoxNo());
            }else {
                throw new CoolException("参数：木箱编号 boxNo:"+matList.getBoxNo()+",木箱编码存在重复");
                throw new CoolException("参数：木箱编号 boxNo:"+matList.getBatch()+",木箱编码存在重复");
            }
        }

@@ -757,37 +803,40 @@


        Date now = new Date();
        for (PalletizingCompleteParam.MatList matList:param.getMatLists()){
            long rollUp = new Date().getTime();
        for (PalletizingCompleteTwoFloorParam.MatList matList:param.getMatList()){
            Mat mat = matService.selectByMatnr(matList.getMatnr());
            if (Cools.isEmpty(mat)) {
                throw new CoolException(matList.getMatnr() + "商品档案不存在");
                mat = new Mat();
                mat.setMatnr(matList.getMatnr());
                mat.setMaktx(matList.getMatnr());
                mat.setTagId(tagService.getTop().getId());
                mat.setCreateBy(userId);
                mat.setCreateTime(now);
                mat.setUpdateBy(userId);
                mat.setUpdateTime(now);
                mat.setStatus(1);
                if (!matService.insert(mat)) {
                    throw new CoolException("规格添加失败，请联系管理员");
                }
            }
            WaitPakin waitPakin = new WaitPakin();
            waitPakin.sync(mat);
            waitPakin.setModel(matList.getBatch());     //批次
            waitPakin.setSpecs(matList.getSpecs());     //规格
            waitPakin.setBatch(matList.getBoxNo());       //木箱编码
            waitPakin.setBatch(matList.getBatch());       //木箱编码  //批次  唯一值  箱号
            waitPakin.setModel(matList.getModel());       //卷号  唯一值
            waitPakin.setBrand(param.getBoxType());     //木箱类型
            waitPakin.setZpallet(param.getBarcode());   //托盘码
            waitPakin.setOrigin(matList.getPosition()); //木箱在托盘上的位置
            waitPakin.setWeight(matList.getWeight());  //净重
            waitPakin.setVolume(matList.getRoughWeight());  //毛重
            waitPakin.setPrice(matList.getRollExtent());   //长度
            waitPakin.setSpecs(String.valueOf(matList.getJoint()));   //接头
            waitPakin.setIoStatus("N");     // 入出状态
            waitPakin.setAnfme(matList.getAnfme().doubleValue());  // 木箱中铜箔数量
            waitPakin.setAnfme(matList.getAnfme());  // 数量
            waitPakin.setStatus("Y");    // 状态
            waitPakin.setAppeUser(userId);
            waitPakin.setAppeTime(now);
            waitPakin.setModiUser(userId);
            waitPakin.setModiTime(now);
            waitPakin.setRollUp(rollUp);
            if (!Cools.isEmpty(matList.getMatDetlList())){
                for (PalletizingCompleteParam.MatDetlList matDetlList:matList.getMatDetlList()){
                    LocDetlRullUpDetail locDetlRullUpDetail = new LocDetlRullUpDetail();
                    locDetlRullUpDetail.setUuid(rollUp);
                    locDetlRullUpDetail.setRollNo(matDetlList.getBoxNoDetl());
                    locDetlRullUpDetail.setRollWeight(matDetlList.getWeightDetl().toString());
                    locDetlRullUpDetailService.insert(locDetlRullUpDetail);
                }
            }
            if (!waitPakinService.insert(waitPakin)) {
                throw new CoolException("保存入库通知档失败");
            }
@@ -801,163 +850,18 @@
    @Override
    @Transactional
    public void palletizingCompleteS(PalletizingCompleteParam param) {
        Long userId = 7776L;//松盛
        //判断param参数
        if (Cools.isEmpty(param.getBarcode())){
            throw new CoolException("参数：托盘码 barcode为空");
        }else if (Cools.isEmpty(param.getPalletizingNo())){
            throw new CoolException("参数：码垛位编号 palletizingNo为空");
        }else if (Cools.isEmpty(param.getBoxType())){
            throw new CoolException("参数：木箱类型 boxType为空");
        }else if (Cools.isEmpty(param.getMatLists()) || param.getMatLists().size()!=1){
            throw new CoolException("参数：物料明细 matLists为空");
        }

        ArrayList<String> positions = new ArrayList<>();   //木箱位置查重      (orgin)
        ArrayList<String> boxNos = new ArrayList<>();   //木箱唯一编码查重  （batch）
        //判断matLists参数
        for (PalletizingCompleteParam.MatList matList:param.getMatLists()){
            if (Cools.isEmpty(matList.getMatnr())){
                throw new CoolException("参数：物料编码 matnr为空");
            }else if (Cools.isEmpty(matList.getPosition())){
                throw new CoolException("物料编码："+matList.getMatnr()+"、参数：码垛位置 position为空");
            }else if (Cools.isEmpty(matList.getBoxNo())){
                throw new CoolException("物料编码："+matList.getMatnr()+"、参数：木箱编号 boxNo为空");
            }else if (Cools.isEmpty(matList.getAnfme()) || matList.getAnfme().equals(0)){
                throw new CoolException("物料编码："+matList.getMatnr()+"、参数：木箱中铜箔数量 anfme为空");
            }else if (Cools.isEmpty(matList.getWeight()) || matList.getWeight().equals(0D)){
                throw new CoolException("物料编码："+matList.getMatnr()+"、参数：重量 weight为空");
            }

            if (!positions.contains(matList.getPosition())){
                positions.add(matList.getPosition());
            }else {
                throw new CoolException("参数：木箱编号 boxNo:"+matList.getBoxNo()+",木箱位置存在重复："+matList.getPosition());
            }

            if (!boxNos.contains(matList.getBoxNo())){
                boxNos.add(matList.getBoxNo());
            }else {
                throw new CoolException("参数：木箱编号 boxNo:"+matList.getBoxNo()+",木箱编码存在重复");
            }
        WrkMast wrkMast = wrkMastService.selectByBarcode(param.getBarcode());
        if (Cools.isEmpty(wrkMast) || wrkMast.getWrkSts()!=2){
            log.error("退库码垛完成，返回托盘码未查询到工作档案！");
            throw new CoolException("参数：托盘码 barcode未查询到工作档案");
        }

        BasDevp basDevp = basDevpService.selectById(param.getPalletizingNo2());
        if (Cools.isEmpty(basDevp)){
            throw new CoolException("参数：码垛位编号 palletizingNo="+param.getPalletizingNo2()+"不存在");
        }
        if (Cools.isEmpty(basDevp.getAutoing()) || !basDevp.getAutoing().equals("Y")){
            throw new CoolException("码垛位编号 palletizingNo="+param.getPalletizingNo()+" 所处站点不是自动状态");
        }
        if (Cools.isEmpty(basDevp.getLoading()) || !basDevp.getLoading().equals("Y")){
            throw new CoolException("码垛位编号 palletizingNo="+param.getPalletizingNo()+" 所处站点不是有物状态");
        }
//        if (Cools.isEmpty(basDevp.getCanining()) || !basDevp.getCanining().equals("Y")){
//            throw new CoolException("码垛位编号 palletizingNo="+param.getPalletizingNo()+" 所处站点不是能入状态");
//        }


        if (locDetlService.selectCount(new EntityWrapper<LocDetl>().eq("zpallet", param.getBarcode()))!=0
                || wrkDetlService.selectCount(new EntityWrapper<WrkDetl>().eq("zpallet", param.getBarcode()))!=0
                || waitPakinService.selectCount(new EntityWrapper<WaitPakin>().eq("zpallet", param.getBarcode()))!=0){
            throw new CoolException("托盘条码："+param.getBarcode()+"已存在，请勿重复组托");
        }


        Date now = new Date();
        List<WaitPakin> waitPakins = new ArrayList<>();
        String matnr = null;
        for (PalletizingCompleteParam.MatList matList:param.getMatLists()){
            long rollUp = new Date().getTime();
            Mat mat = matService.selectByMatnr(matList.getMatnr());
            if (Cools.isEmpty(mat)) {
                throw new CoolException(matList.getMatnr() + "商品档案不存在");
            }
            matnr = mat.getMatnr();
            WaitPakin waitPakin = new WaitPakin();
            waitPakin.sync(mat);
            waitPakin.setModel(matList.getBatch());     //批次
            waitPakin.setSpecs(matList.getSpecs());     //规格
            waitPakin.setBatch(matList.getBoxNo());       //木箱编码
            waitPakin.setBrand(param.getBoxType());     //木箱类型
            waitPakin.setZpallet(param.getBarcode());   //托盘码
            waitPakin.setOrigin(matList.getPosition()); //木箱在托盘上的位置
            waitPakin.setIoStatus("Y");     // 入出状态
            waitPakin.setAnfme(matList.getAnfme().doubleValue());  // 木箱中铜箔数量
            waitPakin.setStatus("Y");    // 状态
            waitPakin.setAppeUser(userId);
            waitPakin.setAppeTime(now);
            waitPakin.setModiUser(userId);
            waitPakin.setModiTime(now);
            waitPakin.setRollUp(rollUp);
            if (!Cools.isEmpty(matList.getMatDetlList())){
                for (PalletizingCompleteParam.MatDetlList matDetlList:matList.getMatDetlList()){
                    LocDetlRullUpDetail locDetlRullUpDetail = new LocDetlRullUpDetail();
                    locDetlRullUpDetail.setUuid(rollUp);
                    locDetlRullUpDetail.setRollNo(matDetlList.getBoxNoDetl());
                    locDetlRullUpDetail.setRollWeight(matDetlList.getWeightDetl().toString());
                    locDetlRullUpDetailService.insert(locDetlRullUpDetail);
                }
            }
            if (!waitPakinService.insert(waitPakin)) {
                throw new CoolException("保存入库通知档失败");
            }
            waitPakins.add(waitPakin);
        }
        LocTypeDto locTypeDto = new LocTypeDto();
        locTypeDto.setLocType1((short)1);

        StartupDto dto = commonService.getLocNo(1, 1, param.getPalletizingNo2(), matnr,null,null, locTypeDto);

        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); // 优先级
        wrkMast.setCrnNo(dto.getCrnNo());
        wrkMast.setSourceStaNo(dto.getSourceStaNo());
        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(0); // 容器类型
        // 操作人员数据
        wrkMast.setAppeTime(now);
        wrkMast.setModiTime(now);
        boolean res = wrkMastService.insert(wrkMast);
        if (!res) {
            throw new CoolException("保存工作档失败");
        }
        // 生成工作档明细
        waitPakins.forEach(waitPakin -> {
            WrkDetl wrkDetl = new WrkDetl();
            wrkDetl.sync(waitPakin);
            wrkDetl.setWrkNo(wrkMast.getWrkNo());
            wrkDetl.setIoTime(wrkMast.getIoTime());
            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()+"目标库位已被占用");
        }
        wrkMast.setSheetNo("4");
        wrkMastService.updateById(wrkMast);
    }


@@ -1001,17 +905,17 @@
            }else if (Cools.isEmpty(matList.getBoxNo())){
                throw new CoolException("参数：木箱编号 boxNo为空");
            }
            List<WrkDetlSingle> wrkDetlSingles = wrkDetlSingleService.selectList(new EntityWrapper<WrkDetlSingle>().eq("batch", matList.getBoxNo()));
            WrkDetlSingle wrkDetlSingleOne = wrkDetlSingleService.selectOne(new EntityWrapper<WrkDetlSingle>().eq("batch", matList.getBoxNo()));
            List<WrkDetlSingle> wrkDetlSingles = wrkDetlSingleService.selectList(new EntityWrapper<WrkDetlSingle>()
                    .eq("wrk_no", wrkDetlSingleOne.getWrkNo()).eq("io_time", wrkDetlSingleOne.getIoTime()));
            boolean sign=true;
            for (WrkDetlSingle wrkDetlSingle:wrkDetlSingles){
                if (wrkDetlSingle.getBatch().equals(matList.getBoxNo())){//木箱编码
                    WrkDetl wrkDetl = new WrkDetl();
                    wrkDetl.sync(wrkDetlSingle);
                    wrkDetlsNew.add(wrkDetl);
                    wrkDetlsOld.add(wrkDetlSingle);
                    sign=false;
                    break;
                }
                WrkDetl wrkDetl = new WrkDetl();
                wrkDetl.sync(wrkDetlSingle);
                wrkDetlsNew.add(wrkDetl);
                wrkDetlsOld.add(wrkDetlSingle);
                sign=false;
                break;
            }
            if (sign){
                throw new CoolException("参数：木箱编号 boxNo未查询到对应的工作明细！");
@@ -1065,69 +969,20 @@
    @Override
    @Transactional
    public void singleMountUnstackingComplete(SingleMountUnstackingCompleteParam param) {
        Long userId = 8888L;//桁架上位软件
//        Long userId = 8888L;//桁架上位软件
        //判断param参数
        if (Cools.isEmpty(param.getBarcode())){
            throw new CoolException("参数：托盘码 barcode为空");
        }
//        else if (Cools.isEmpty(param.getPalletizingNo())){
//            throw new CoolException("参数：码垛位编号 palletizingNo为空");
//        }
        WrkMast wrkMastMatrix = wrkMastService.selectByBarcode(param.getBarcode());
        if (Cools.isEmpty(wrkMastMatrix)){
            throw new CoolException("参数：托盘码查询工作档失败："+param.getBarcode());
        }else {
//            if (wrkMastMatrix.getIoType().equals(103)){
//                List<WrkDetl> wrkDetls = wrkDetlService.selectByWrkNoUnstacking(wrkMastMatrix.getWrkNo());
//                if (Cools.isEmpty(param.getMatLists()) || param.getMatLists().size()==0 || param.getMatLists().size()!=wrkDetls.size()){
//                    throw new CoolException("返回物料明细数为"+param.getMatLists().size()+",托盘码："+param.getBarcode()+"应剩余物料数："+wrkDetls.size());
//                }
//
//                ArrayList<String> orgin = new ArrayList<>();
//                //判断matLists参数
//                for (SingleMountUnstackingCompleteParam.MatList matList : param.getMatLists()){
//                    if (Cools.isEmpty(matList.getPosition())){
//                        throw new CoolException("参数：码垛位置 position为空");
//                    }else if (Cools.isEmpty(matList.getBoxNo())){
//                        throw new CoolException("参数：木箱编号 boxNo为空");
//                    }
//                    if (!orgin.contains(matList.getPosition())){
//                        orgin.add(matList.getPosition());
//                    }else {
//                        throw new CoolException("参数：木箱编号 boxNo:"+matList.getBoxNo()+",木箱位置存在重复");
//                    }
//                    boolean sign=true;
//                    for (WrkDetl wrkDetl:wrkDetls){
//                        if (wrkDetl.getBatch().equals(matList.getBoxNo())){//木箱编码
//                            wrkDetl.setOrigin(matList.getPosition());
//                            wrkDetlService.update(wrkDetl,new EntityWrapper<WrkDetl>().eq("batch",wrkDetl.getBatch()));
//                            sign=false;
//                            break;
//                        }
//                    }
//                    if (sign){
//                        throw new CoolException("参数：木箱编号 boxNo:"+matList.getBoxNo()+"未查询到对应的工作明细！");
//                    }
//                }
//            }
        }

        wrkMastMatrix.setSheetNo("2");
        if (!wrkMastService.updateById(wrkMastMatrix)){
            throw new CoolException("更新工作档失败==》桁架上位软件：单托拆垛完成通知");
        }
    }

    /*
     *
     * */
    @Override
    @Transactional
    public void cs1(String barcode) {
        BasDevp basDevp = basDevpService.selectById(216);
        basDevp.setWrkNo(9992);
        basDevp.setBarcode(barcode);
        basDevpService.updateById(basDevp);
    }

    /*
@@ -1145,6 +1000,803 @@
//        }

    }

    @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) {

        if (Cools.isEmpty(param)) {
            throw new CoolException("请求参数有误：" + param);
        }
        if (!Cools.isEmpty(param.getBarcode())) {
            int zpalletCount = locDetlService.selectCount(new EntityWrapper<LocDetl>().eq("zpallet", param.getBarcode()));
            if (zpalletCount > 0) {
                throw new CoolException("库存托盘码已存在：" + param.getBarcode());
            }

            int barcodeCount = wrkMastService.selectCount(new EntityWrapper<WrkMast>().eq("barcode", param.getBarcode()));
            if (barcodeCount > 0) {
                throw new CoolException("工作档已存在该托盘码：" + param.getBarcode());
            }
        }
        LocTypeDto locTypeDto = new LocTypeDto();
        locTypeDto.setLocType1((short)1);
        int iotype = 1;
        if (Cools.isEmpty(param.getMatList())) {
            iotype = 10;
        }
        // 根据源站点寻找库位
//        StartupDto dto = commonService.getLocNo(1, 1, param.getPalletizingNo(), null,null,null, locTypeDto);
        StartupDto dto = commonService.getLocNo(iotype, param.getPalletizingNo(), locTypeDto,0);

        // 返回GWCS目标信息
        pushStaNoToGwcs(param.getPalletizingNo(),dto.getStaNo(),dto.getWorkNo(),param.getBarcode(),"gwms申请入库后推送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(iotype); // 入出库状态：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("保存工作档失败");
        }

        if (!Cools.isEmpty(param.getMatList())) {
            List<GwmsGenerateInventoryDto.MatList> matList = param.getMatList();
            for (GwmsGenerateInventoryDto.MatList obj :matList) {
                WrkDetl wrkDetl = new WrkDetl();
                wrkDetl.setWrkNo(wrkMast.getWrkNo());
                obj.getRolls().forEach(roll -> {
                    wrkDetl.setWrkNo(wrkMast.getWrkNo());
                    wrkDetl.setMatnr(roll.getSpecs()); // 规格
                    wrkDetl.setMaktx(roll.getSpecs()); //规格
                    wrkDetl.setUnit(roll.getBoxNo()); // 箱号
                    wrkDetl.setModel(roll.getRollNo()); // 卷号
                    wrkDetl.setBrand(obj.getPackageGroupNo()); // 包装组号
                    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.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("备份物料表失败");
                    }

                });
            }
        }


        // 更新目标库位状态
        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 null;
    }

    @Override
    @Transactional
    public String crnExecute(CrnExecuteParam param) {
        if (Cools.isEmpty(param.getStaNo(),param.getWorkNo())){
            throw new CoolException("参数不能为空：" + param);
        }

        WrkMast wrkMast = wrkMastService.selectOne(new EntityWrapper<WrkMast>().eq("wrk_no", param.getWorkNo()));
        if (wrkMast == null) {
            throw new CoolException("不存在该工作号：" + param.getWorkNo());
        }

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

        return "请求成功";
    }

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

        Order order = orderService.selectByNo(param.getOrderNo());
        if (!Cools.isEmpty(order)) {
            throw new CoolException(param.getOrderNo() + "单据已存在，请勿重复提交");
        }

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

        // 单据主档
        order = new Order(
                String.valueOf(snowflakeIdWorker.nextId()),    // 编号[非空]
                param.getOrderNo(),    // 订单编号
                DateUtils.convert(now),    // 单据日期
                docType.getDocId(),    // 单据类型
                null,    // 项目编号
                null,    //
                null,    // 调拨项目编号
                null,    // 初始票据号
                null,    // 票据号
                null,    // 客户编号
                null,    // 客户
                null,    // 联系方式
                null,    // 操作人员
                null,    // 合计金额
                null,    // 优惠率
                null,    // 优惠金额
                null,    // 销售或采购费用合计
                null,    // 实付金额
                null,    // 付款类型
                null,    // 业务员
                null,    // 结算天数
                null,    // 邮费支付类型
                null,    // 邮费
                null,    // 付款时间
                null,    // 发货时间
                null,    // 物流名称
                null,    // 物流单号
                1L,    // 订单状态
                1,    // 状态
                9527L,    // 添加人员
                now,    // 添加时间
                9527L,    // 修改人员
                now,    // 修改时间
                null    // 备注
        );

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

        // 单据明细档
        for (String groupNo : param.getGroups()) {
            OrderDetl orderDetl = new OrderDetl();
            orderDetl.setBrand(groupNo);
            orderDetl.setBatch("");
            orderDetl.setOrderId(order.getId());
            orderDetl.setOrderNo(order.getOrderNo());
            orderDetl.setCreateBy(9527L);
            orderDetl.setCreateTime(now);
            orderDetl.setUpdateBy(9527L);
            orderDetl.setUpdateTime(now);
            orderDetl.setStatus(1);
            orderDetl.setQty(0.0D);
            orderDetl.setAnfme(1.0);
            if (!orderDetlService.insert(orderDetl)) {
                throw new CoolException("生成单据明细失败，请联系管理员");
            }
        }

        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
    @Transactional
    public String outLocResultReport(GhjtApiParam param) {

        if (Cools.isEmpty(param.getOutLocResult(),param.getWorkNo())) {
            throw new CoolException("入参不能为空：" + param);
        }

        WrkMast wrkMast = wrkMastService.selectOne(new EntityWrapper<WrkMast>().eq("wrk_no", param.getWorkNo()));
        if (wrkMast == null) {
            throw new CoolException("该工作档不存在，任务号：" + param.getWorkNo());
        } else if(wrkMast.getWrkSts() != 2) {
            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 (!flag || wrkMast.getIoType() == 110) {
                wrkMast.setWrkSts(14L);
//            }
            wrkMastService.updateById(wrkMast);
        }

        return "出库结果上报成功";
    }

    @Autowired
    private BasCrnpService basCrnpService;

    @Override
    @Transactional
    public String emptyOutLoc(GhjtApiParam param) {
//        3102/3009/3008/3006/3003/3002→3047/3112
        // 获取模式为电脑模式，无任务的堆垛机列表:防止分配到堆垛机不可用
        List<BasCrnp> basCrnps = basCrnpService.selectList(new EntityWrapper<BasCrnp>().eq("crn_sts",3)
                .eq("wrk_no",0));
        if (basCrnps.isEmpty()) {
            // 都有任务则获取电脑模式的堆垛机列表
            basCrnps = basCrnpService.selectList(new EntityWrapper<BasCrnp>().eq("crn_sts",3));
        }
        if (basCrnps.isEmpty()) {
            throw new CoolException("没有可用堆垛机,堆垛机停止或异常");
        }
        // 可用堆垛机列表
        List<Integer> crnNoList = basCrnps.stream().map(BasCrnp::getCrnNo).collect(Collectors.toList());
        // 寻找空托盘库位，先找浅库位
        List<LocMast> locMasts;
            locMasts = locMastService.selectList(new EntityWrapper<LocMast>().eq("loc_sts","D")
                    .orderAsc(Arrays.asList("row1","lev1","bay1")).in("crn_no",crnNoList).in("row1",3,4,6,7,10,11,14,15,18,19,22,23));
            if (locMasts.isEmpty()) {
                locMasts = locMastService.selectList(new EntityWrapper<LocMast>().eq("loc_sts","D")
                        .orderAsc(Arrays.asList("row1","lev1","bay1")).in("crn_no",crnNoList).in("row1",1,4,5,8,9,12,13,16,17,20,21,24));
            }

        if (locMasts.isEmpty()) {
            throw new CoolException("没有找到空托盘，站点：" + param.getStaNo());
        }

        // 取第一个空库位
        LocMast locMast = locMasts.get(0);

        // 获取工作路径
        StaDesc staDesc = staDescService.selectOne(new EntityWrapper<StaDesc>().eq("type_no", 110).eq("stn_no",
                param.getStaNo()).eq("crn_no", locMast.getCrnNo()));

        if (staDesc == null) {
            throw new CoolException("路径不存在");
        }

        //2.生成空托盘出库工作档
        Date now = new Date();
        WrkMast wrkMast = new WrkMast();
        wrkMast.setWrkNo(commonService.getWorkNo(WorkNoType.PAKOUT.type));
        wrkMast.setIoTime(now);
        wrkMast.setWrkSts(11L); // 工作状态：11.生成出库ID
        wrkMast.setIoType(110); // 入出库状态： 110.空板出库
        wrkMast.setIoPri(10D);
        wrkMast.setSourceStaNo(staDesc.getCrnStn()); // 源站
        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"); // 退出
        wrkMast.setEmptyMk("Y"); // 空板
        wrkMast.setLinkMis("N");
        wrkMast.setAppeUser(9999L);
        wrkMast.setAppeTime(now);
        wrkMast.setModiUser(9999L);
        wrkMast.setModiTime(now);
        if (!wrkMastService.insert(wrkMast)) {
            throw new CoolException("保存工作档失败");
        }

        // 3.更新库位状态 D.空板 -> R.出库预约
        if (locMast.getLocSts().equals("D")) {
            locMast.setLocSts("R");
            locMast.setModiUser(9999L);
            locMast.setModiTime(now);
            if (!locMastService.updateById(locMast)) {
                throw new CoolException("更新库位状态失败");
            }
        }

        return "出库成功";
    }

    @Override
    @Transactional
    public R zphjDw(ZphjckdwParam param) {
        // 根据任务号得到工作主档
        if (Cools.isEmpty(param.getWorkNo())) {
            throw new CoolException("工作号不能为空！");
        }
        WrkMast wrkMast = wrkMastService.selectById(param.getWorkNo());
        if (wrkMast == null) {
            throw new CoolException("工作档不存在！");
        }
        if (wrkMast.getWrkSts() != 2 || wrkMast.getIoType() != 103) {
            throw new CoolException("工作档当前状态不为2/出库类型不为拣料！");
        }
        // 更新工作档状态2.设备上走->42.等待码垛
        wrkMast.setWrkSts(42L);
        wrkMastService.updateById(wrkMast);

        // 查询要拆的位置，只有一个
        List<WrkDetl> wrkDetls = wrkDetlService.selectList(new EntityWrapper<WrkDetl>().eq("wrk_no", wrkMast.getWrkNo()));
        WrkDetl wrkDetl = wrkDetls.get(0);

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

        return R.ok(zphjcdgzVo);
    }

    @Override
    @Transactional
    public R zphjCdwc(ZphjcdwcParam param) {

        if (Cools.isEmpty(param.getWorkNo(),param.getBarcode(),param.getSourceStaNo(),param.getSite())) {
            return R.parse("参数不能为空，请检查入参");
        }
        WrkMast wrkMast = wrkMastService.selectById(param.getWorkNo());
        if (wrkMast == null) {
            throw new CoolException("工作档不存在！");
        }
        if (wrkMast.getWrkSts() != 42 || wrkMast.getIoType() != 103) {
            throw new CoolException("工作档当前状态不为42/出库类型不为拣料！");
        }

        // 获取出库物料
        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.getSourceStaNo());
        zphjcdwcVo1.setSourceStaNo(param.getSourceStaNo());
        zphjcdwcVo1.setBarcode(wrkMast.getBarcode());
        zphjcdwcVos.add(zphjcdwcVo1);

        ZphjcdwcVo zphjcdwcVo2 = new ZphjcdwcVo();
        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);
        // 修改库位状态 Q.拣料/盘点/并板再入库
        LocMast locMast = locMastService.selectById(wrkMast.getLocNo());
        locMast.setLocSts("Q");
        locMast.setModiTime(new Date());
        if (!locMastService.updateById(locMast)) {
            throw new CoolException("修改库位状态失败");
        }

        // 下发回库的目标站点和拆垛的出库目标站点给gwcs
        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 1.多卷直接出路径，4.单卷贴标路径
     */
    private int getType(List<WrkDetl> wrkDetls) {
        return wrkDetls.size() > 1 ? 1 : 4; // 一条记录就是一卷
    }

    public boolean pushStaNoToGwcs(Integer palletizingNo, Integer staNo, Integer workNo,String barcode,String message) {
        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;
            } else {
                log.error(message + "失败！！！url：{}；request：{}；response：{}", MesConstant.URL + MesConstant.PAKIN_URL, body, response);
            }
        } catch (Exception e) {
            log.error(message + "异常：{}", e);
        } finally {
            try {
                // 保存接口日志
                apiLogService.save(
                        message,
                        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 void descSta(Integer staNo,Integer crnNo){
//        int[] typeNos =new int[]{1,10,53,101,103,110};
@@ -1206,24 +1858,6 @@
            return crnStn-2;
        }
        return crnStn;
    }


        /*
     *
     * */
    @Override
    @Transactional
    public void cs3() {
        //拆盘
        WrkMastSta wrkMastSta1 = new WrkMastSta(new Date(),119);
        wrkMastSta1.setType(2);
        wrkMastSta1.setWrkType(2);
        wrkMastStaService.insert(wrkMastSta1);
        WrkMastSta wrkMastSta2 = new WrkMastSta(new Date(),121);
        wrkMastSta2.setType(2);
        wrkMastSta2.setWrkType(2);
        wrkMastStaService.insert(wrkMastSta2);
    }

    /*...........................上饶江铜..............以上.............徐工汉云...........................*/