#

zwl

2025-07-19 6193eddf242c4b879402367704b8b5b2e8df84a4

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

@@ -22,6 +22,7 @@
import com.zy.asrs.utils.Utils;
import com.zy.common.service.CommonService;
import com.zy.common.utils.HttpHandler;
import com.zy.common.utils.RedisUtil;
import com.zy.core.CrnThread;
import com.zy.core.DevpThread;
import com.zy.core.cache.MessageQueue;
@@ -103,15 +104,21 @@
    private String TaskExecCallback;
    @Value("${wms.taskStatusFeedbackPath}")
    private String taskStatusFeedbackPath;
    @Value("${wms.returnWarehouse}")
    private String returnWarehouse;

    @Value("${wcs.urlWcs}")
    private String wcsUrl;
    @Value("${wcs.inboundTaskApplyPathWcs}")
    private String wcsInboundTaskApplyPath;
    @Value("${wcs.outboundTaskRequest}")
    private String outboundTaskRequest;
    @Autowired
    private CrnController crnController;
    @Autowired
    private SiteController siteController;
    @Autowired
    private RedisUtil redisUtil;


    public synchronized void generateStoreWrkFile1() throws IOException, InterruptedException {
@@ -134,7 +141,7 @@
                    // 判断是否满足入库条件
                    if (staProtocol.isAutoing() && staProtocol.isLoading()
                            && staProtocol.isInEnable()
                            && !staProtocol.isEmptyMk() && workNo >= 9790
                            && !staProtocol.isEmptyMk() && workNo >= 9998
                            && staProtocol.isPakMk()) {
                        // 获取条码扫描仪信息
                        BarcodeThread barcodeThread = (BarcodeThread) SlaveConnection.get(SlaveType.Barcode, inSta.getBarcode());
@@ -145,17 +152,17 @@
                        if (BoxNo.equals("00000000")) {
                            storageEscalationParam.setWCSStatus(1);
                            storageEscalationParam.setWCSErrorMessage("没有扫到码");
                            BasDevp basDevp= basDevpService.selectOne(new EntityWrapper<BasDevp>()
                                    .eq("dev_no",staProtocol.getSiteId()));
                            if(Cools.isEmpty(basDevp)){
                                log.error("扫码失败并且没有找到该站点---"+staProtocol.getSiteId());
                            }else{
                            BasDevp basDevp = basDevpService.selectOne(new EntityWrapper<BasDevp>()
                                    .eq("dev_no", staProtocol.getSiteId()));
                            if (Cools.isEmpty(basDevp)) {
                                log.error("扫码失败并且没有找到该站点---" + staProtocol.getSiteId());
                            } else {
                                basDevp.setStaErr(1);//没有扫到码
                                basDevp.setStaErrMsg("没有扫到码！");
                                basDevpService.updateById(basDevp);
                            }
                            continue;
                        }else{
                        } else {
                            TaskWrk taskWrk1 = taskWrkService.selectOne(new EntityWrapper<TaskWrk>().eq("barcode", BoxNo));
                            if (!Cools.isEmpty(taskWrk1)) {
                                log.info("托盘码：" + BoxNo + "任务档存在");
@@ -185,24 +192,26 @@
                                    .doPost();
                            JSONObject jsonObject = JSON.parseObject(response);

                            if (!Cools.isEmpty(response) && !Cools.isEmpty(jsonObject.get("ReturnStatus")) && jsonObject.get("ReturnStatus").equals(0) && !Cools.isEmpty(jsonObject.get("Result").toString())) {
                                Result result = JSON.parseObject(jsonObject.get("Result").toString(), Result.class);
                            if (!Cools.isEmpty(response) && !Cools.isEmpty(jsonObject.get("returnStatus")) && jsonObject.get("returnStatus").equals(0) && !Cools.isEmpty(jsonObject.get("results").toString())) {
                                Result result = JSON.parseObject(jsonObject.get("results").toString(), Result.class);
                                // 创新一个入库工作档
                                TaskWrk taskWrk = taskWrkService.selectByTaskNo(result.getTaskNo()+"");
                                TaskWrk taskWrk = taskWrkService.selectByTaskNo(result.getTaskNo() + "");
                                if (Cools.isEmpty(taskWrk)) {
                                    taskWrk = createTask1(result, BoxNo,staProtocol.getSiteId());
                                    taskWrk = createTask1(result, BoxNo, staProtocol.getSiteId());
                                    if (Cools.isEmpty(taskWrk)) {
                                        log.error("库位异常，库位号：={}", taskWrk.getOriginTargetPoint());
                                    } else {
                                        taskWrkService.insert(taskWrk);
                                        StaDesc staDesc = staDescService.selectOne(new EntityWrapper<StaDesc>()
                                                .eq("crn_no", taskWrk.getCrnNo()).eq("type_no", 1).eq("stn_no", staProtocol.getSiteId()));
                                        staProtocol.setWorkNo(taskWrk.getWrkNo().shortValue());
                                        staProtocol.setStaNo(staDesc.getCrnStn().shortValue());
                                        MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                                        HashMap<String, Object> hashMap = new HashMap<>();
                                        hashMap.put("TaskNo", taskWrk.getTaskNo());
                                        Boolean bool = false;

                                        staProtocol.setWorkNo(taskWrk.getWrkNo().shortValue());
                                        staProtocol.setStaNo((short) 0);
                                        MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));

                                        try {
                                            //开始上报,任务开始时，WCS回调WMS
                                            response = new HttpHandler.Builder()
@@ -212,9 +221,139 @@
                                                    .build()
                                                    .doPost();
                                            JSONObject jsonObject1 = JSON.parseObject(response);

                                            if (jsonObject1.get("ReturnStatus").equals(0)) {
                                                bool = true;

                                            }

                                        } catch (Exception e) {

                                        } finally {
                                            apiLogService.save("wcs开始入库任务上报wms"
                                                    , wmsUrl + TaskExecCallback
                                                    , null
                                                    , "127.0.0.1"
                                                    , JSON.toJSONString(hashMap)
                                                    , response
                                                    , bool
                                            );
                                        }
                                    }
                                }
                            }
                        } catch (Exception e) {
                            log.error("请求入库调用接口失败");
                            log.error("异常信息打印：" + e);
                            try {
                                BasDevp basDevp = basDevpService.selectById(inSta.getStaNo());
                                if (Cools.isEmpty(basDevp)) {
                                    log.error("站点号异常" + inSta.getStaNo());
                                } else if (basDevp.getStaErr() != 0) {
                                    basDevp.setStaErr(2);
                                    basDevpService.updateById(basDevp);
                                }
                            } catch (Exception e1) {
                                // 退回
                                log.error("扫码检测程序异常" + inSta.getStaNo() + "异常信息" + e1);
                            }
                        } finally {
                            apiLogService.save("wms请求入库货位接口"
                                    , wmsUrl + inboundTaskApplyPath
                                    , null
                                    , "127.0.0.1"
                                    , JSON.toJSONString(storageEscalationParam)
                                    , response
                                    , success
                            );
                        }
                        log.info("入库请求参数=" + JSON.toJSONString(BoxNo));
                        log.info("入库请求返回参数=" + JSON.toJSONString(response));
                    }
                }
            }
        } catch (Exception e) {
            log.error("generateStoreWrkFile e", e);
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        }
    }

    public synchronized void EmptyPlates() throws IOException, InterruptedException {
        try {
            // 根据输送线plc遍历
            for (DevpSlave devp : slaveProperties.getDevp()) {
                // 遍历入库口
                for (DevpSlave.Sta inSta : devp.getInSta()) {
                    StorageEscalationParam storageEscalationParam = new StorageEscalationParam();
                    // 获取入库站信息
                    DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
                    StaProtocol staProtocol = devpThread.getStation().get(inSta.getStaNo());
                    if (staProtocol == null) {
                        continue;
                    } else {
                        staProtocol = staProtocol.clone();
                    }
                    Short workNo = staProtocol.getWorkNo();
                    Short stano = staProtocol.getStaNo();
                    // 判断是否满足入库条件
                    if (staProtocol.isAutoing() && staProtocol.isLoading()
                            && staProtocol.isInEnable()
                            && staProtocol.isEmptyMk() && workNo ==9999
                            && staProtocol.isPakMk()) {
                        // 获取条码扫描仪信息
                        BarcodeThread barcodeThread = (BarcodeThread) SlaveConnection.get(SlaveType.Barcode, inSta.getBarcode());
                        if (barcodeThread == null) {
                            continue;
                        }
                        String BoxNo = barcodeThread.getBarcode();

                        log.info("组托入库={}", storageEscalationParam);
                        storageEscalationParam.setBoxNo(BoxNo);
                        storageEscalationParam.setWcsIoType(2);//空板
                        storageEscalationParam.setWcsSourceStaNo(staProtocol.getSiteId());
                        String response = "";
                        Boolean success = false;
                        try {
                            response = new HttpHandler.Builder()
                                    .setUri(wmsUrl)
                                    .setPath(inboundTaskApplyPath)
                                    .setJson(JSON.toJSONString(storageEscalationParam))
                                    .build()
                                    .doPost();
                            JSONObject jsonObject = JSON.parseObject(response);

                            if (!Cools.isEmpty(response) && !Cools.isEmpty(jsonObject.get("returnStatus")) && jsonObject.get("returnStatus").equals(0) && !Cools.isEmpty(jsonObject.get("results").toString())) {
                                Result result = JSON.parseObject(jsonObject.get("results").toString(), Result.class);
                                // 创新一个入库工作档
                                TaskWrk taskWrk = taskWrkService.selectByTaskNo(result.getTaskNo() + "");
                                if (Cools.isEmpty(taskWrk)) {
                                    taskWrk = createTask1(result, BoxNo, staProtocol.getSiteId());
                                    if (Cools.isEmpty(taskWrk)) {
                                        log.error("库位异常，库位号：={}", taskWrk.getOriginTargetPoint());
                                    } else {
                                        devpThread.setPakMk(staProtocol.getSiteId(), false);
                                        taskWrkService.insert(taskWrk);
                                        StaDesc staDesc = staDescService.selectOne(new EntityWrapper<StaDesc>()
                                                .eq("crn_no", taskWrk.getCrnNo()).eq("type_no", 1).eq("stn_no", staProtocol.getSiteId()));
                                        HashMap<String, Object> hashMap = new HashMap<>();
                                        hashMap.put("TaskNo", taskWrk.getTaskNo());
                                        Boolean bool = false;

                                        staProtocol.setWorkNo(taskWrk.getWrkNo().shortValue());
                                        staProtocol.setStaNo((short) 0);
                                        MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));

                                        try {
                                            //开始上报,任务开始时，WCS回调WMS
                                            response = new HttpHandler.Builder()
                                                    .setUri(wmsUrl)
                                                    .setPath(taskStatusFeedbackPath)
                                                    .setJson(JSON.toJSONString(hashMap))
                                                    .build()
                                                    .doPost();
                                            JSONObject jsonObject1 = JSON.parseObject(response);
                                            if (jsonObject1.get("ReturnStatus").equals(0)) {
                                                bool = true;

                                            }

                                        } catch (Exception e) {
@@ -272,55 +411,56 @@
     * 堆垛机站出库到出库站
     */
    public synchronized void crnStnToOutStn() {
        for (CrnSlave crnSlave : slaveProperties.getCrn()) {
            // 遍历堆垛机出库站
            for (CrnSlave.CrnStn crnStn : crnSlave.getCrnOutStn()) {
                List<StaDesc> staDescs = staDescMapper.selectList(new EntityWrapper<StaDesc>().eq("crn_no", crnSlave.getId()).eq("crn_stn", crnStn.getStaNo()));
                for (StaDesc staDesc : staDescs) {
                    try {
                        // 获取堆垛机出库站信息
                        DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, crnStn.getDevpPlcId());
                        StaProtocol staProtocol = devpThread.getStation().get(crnStn.getStaNo());
                        if (staProtocol == null) {
                            continue;
                        } else {
                            staProtocol = staProtocol.clone();
                        }
                        if (staProtocol.isAutoing() && staProtocol.isLoading() && (staProtocol.getWorkNo() == 0 || staProtocol.getStaNo() == 0)) {
                            // 查询工作档
                            TaskWrk taskWrk = taskWrkMapper.selectCrnStaWorking(crnSlave.getId(), staDesc.getStnNo().toString());
                            if (taskWrk == null) {
                                continue;
                            }
                            log.info("下发输送线任务：taskWrk:" + JSON.toJSONString(taskWrk));
//                            R r = siteController.siteDetlUpdate(Integer.valueOf(taskWrk.getTargetPoint()), taskWrk.getWrkNo().shortValue(), (short) 0, "Y", false, false);
                            staProtocol.setWorkNo(taskWrk.getWrkNo().shortValue());
                            staProtocol.setStaNo(staDesc.getStnNo().shortValue());
                            boolean offer = false;
                            try {
                                offer = MessageQueue.offer(SlaveType.Devp, 1, new Task(2, staProtocol));
                            } catch (Exception e) {
                                log.error("下发输送线任务失败：异常:" + e);
                                log.error("下发输送线任务失败：异常:offer:" + offer);
                            }
//                            JSONObject jsonObject = JSON.parseObject(JSON.toJSONString(r));
                            if (offer) {
                                log.info("下发输送线任务成功：taskWrk:" + JSON.toJSONString(taskWrk));
                                taskWrk.setStatus(5);
                                taskWrk.setWrkSts(16);
                                taskWrkService.updateById(taskWrk);

                            } else {
                                log.error("下发输送线任务失败：taskWrk:" + JSON.toJSONString(taskWrk));
//                                log.error("下发输送线任务失败：异常信息:"+JSON.toJSONString(r));
                            }
                        }
                    } catch (Exception e) {
                        log.error("出库到出库站异常:异常信息：" + e);
        // 根据输送线plc遍历
        for (DevpSlave devp : slaveProperties.getDevp()) {
            // 遍历出库口
            for (DevpSlave.Sta outSta : devp.getOutSta()) {
                try {
                    // 获取堆垛机出库站信息
                    DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
                    StaProtocol staProtocol = devpThread.getStation().get(outSta.getStaNo());
                    if (staProtocol == null) {
                        continue;
                    } else {
                        staProtocol = staProtocol.clone();
                    }
                }
                    if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.getWorkNo() == 0) {
                        // 查询工作档
                        TaskWrk taskWrk = taskWrkService.selectOne(new EntityWrapper<TaskWrk>()
                                .eq("target_point", staProtocol.getSiteId())
                                .eq("wrk_sts", 15));
                        if (taskWrk == null) {
                            continue;
                        }
                        log.info("下发输送线任务：taskWrk:" + JSON.toJSONString(taskWrk));
//                            R r = siteController.siteDetlUpdate(Integer.valueOf(taskWrk.getTargetPoint()), taskWrk.getWrkNo().shortValue(), (short) 0, "Y", false, false);
                        staProtocol.setWorkNo(taskWrk.getWrkNo().shortValue());
                        staProtocol.setStaNo((short) 0);
                        boolean offer = false;
                        try {
                            offer = MessageQueue.offer(SlaveType.Devp, 1, new Task(2, staProtocol));
                        } catch (Exception e) {
                            log.error("下发输送线任务失败：异常:" + e);
                            log.error("下发输送线任务失败：异常:offer:" + offer);
                        }
//                            JSONObject jsonObject = JSON.parseObject(JSON.toJSONString(r));
                        if (offer) {
                            log.info("下发输送线任务成功：taskWrk:" + JSON.toJSONString(taskWrk));
//                            taskWrk.setStatus(5);
                            taskWrk.setWrkSts(16);
                            taskWrkService.updateById(taskWrk);

                        } else {
                            log.error("下发输送线任务失败：taskWrk:" + JSON.toJSONString(taskWrk));
//                                log.error("下发输送线任务失败：异常信息:"+JSON.toJSONString(r));
                        }
                    }
                } catch (Exception e) {
                    log.error("出库到出库站异常:异常信息：" + e);
                }
            }


        }
    }

@@ -328,89 +468,82 @@
     * 入出库  ===>>  调用RCS进行入出库
     */
    public synchronized void crnIoExecute() throws IOException {
        for (CrnSlave crn : slaveProperties.getCrn()) {
            this.crnStnToLoc(crn); //  入库
            this.locToCrnStn(crn); //  出库
            // 库位移转
        this.crnStnToLoc(); //  入库
        this.locToCrnStn(); //  出库
        // 库位移转
//            this.locToLoc(crn, crnProtocol);
        }
    }

    /**
     * 入库  ===>>  堆垛机站到库位
     */
    public synchronized void crnStnToLoc(CrnSlave slave) throws IOException {
        for (CrnSlave.CrnStn crnStn : slave.getCrnInStn()) {
            List<StaDesc> staDescs = staDescMapper.selectList(new EntityWrapper<StaDesc>().eq("crn_no", slave.getId()).eq("crn_stn", crnStn.getStaNo()));
            for (StaDesc staDesc : staDescs) {
                boolean flag = false;
                // 获取堆垛机入库站信息
                DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, crnStn.getDevpPlcId());
                StaProtocol staProtocol = devpThread.getStation().get(crnStn.getStaNo());
    public synchronized void crnStnToLoc() throws IOException {
        // 根据输送线plc遍历
        for (DevpSlave devp : slaveProperties.getDevp()) {
            // 遍历入库口
            for (DevpSlave.Sta inSta : devp.getInSta()) {
                StorageEscalationParam storageEscalationParam = new StorageEscalationParam();
                // 获取入库站信息
                DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
                StaProtocol staProtocol = devpThread.getStation().get(inSta.getStaNo());
                if (staProtocol == null) {
                    continue;
                } else {
                    staProtocol = staProtocol.clone();
                }
                // 查询站点详细信息
                BasDevp staDetl = basDevpService.selectById(crnStn.getStaNo());
                BasDevp staDetl = basDevpService.selectById(staProtocol.getSiteId());
                if (staDetl == null) {
                    log.error("入库 ===>> 堆垛机站点在数据库不存在, 站点编号={}", crnStn.getStaNo());
                    log.error("入库 ===>> 堆垛机站点在数据库不存在, 站点编号={}", staProtocol.getSiteId());
                    continue;
                }
                if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.getWorkNo() > 0 && staProtocol.isInEnable()
                if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.getWorkNo() < 9990
                        && staDetl.getCanining() != null && staDetl.getCanining().equals("Y")) {
                    flag = true;
                }
                if (!flag) {
                    continue;
                }

                // 获取工作状态为2（设备上走）的入库工作档
                TaskWrk taskWrk = taskWrkMapper.selectPakIn(slave.getId(), staProtocol.getWorkNo().intValue(), staDesc.getStnNo().toString());
                if (null == taskWrk) {
                    continue;
                }

                String mbz = taskWrk.getTargetPoint().substring(5);

                HashMap<String, Object> hashMap = new HashMap<>();
                hashMap.put("taskNo", taskWrk.getTaskNo());//wms任务号
                hashMap.put("sourceStaNo", staDetl.getDevNo());//源站点
                hashMap.put("staNo", Integer.parseInt(mbz) + "");//目标站
                hashMap.put("locNo", taskWrk.getTargetPoint());//目标库位
                String response = "";
                Boolean bool = false;
                try {
                    //开始上报,出库任务开始时，WCS回调WMS
                    response = new HttpHandler.Builder()
                            .setUri(wcsUrl)
                            .setPath(wcsInboundTaskApplyPath)
                            .setJson(JSON.toJSONString(hashMap))
                            .build()
                            .doPost();
                    JSONObject jsonObject = JSON.parseObject(response);

                    if (jsonObject.get("code").equals(200)) {
                        bool = true;
//                        taskWrk.setStatus(TaskStatusType.DISTRIBUTE.id);//派发状态
                        taskWrk.setAssignTime(new Date());//派发时间
                        taskWrk.setWrkSts(3);//工作状态 3.成功下发入库任务给RCS
                        taskWrk.setCrnNo(staDesc.getCrnNo());//堆垛机号
                        taskWrk.setModiTime(new Date());
                        taskWrk.setModiUser(9988L);
                    // 获取工作状态为2（设备上走）的入库工作档
                    TaskWrk taskWrk = taskWrkMapper.selectPakIn(null, staProtocol.getWorkNo().intValue(), staProtocol.getSiteId().toString());
                    if (null == taskWrk) {
                        continue;
                    }
                } catch (Exception e) {
                } finally {
                    apiLogService.save("wcs派发入库任务给RCS"
                            , wcsUrl + wcsInboundTaskApplyPath
                            , null
                            , "127.0.0.1"
                            , JSON.toJSONString(hashMap)
                            , response
                            , bool
                    );

                    HashMap<String, Object> hashMap = new HashMap<>();
                    hashMap.put("taskNo", taskWrk.getTaskNo());//wms任务号
                    hashMap.put("sourceStaNo", staDetl.getDevNo());//源站点
                    hashMap.put("staNo", taskWrk.getTargetPoint());//目标站
                    hashMap.put("locNo", taskWrk.getOriginTargetPoint());//目标库位
                    String response = "";
                    Boolean bool = false;
                    try {
                        //开始上报,出库任务开始时，WCS回调WMS
                        response = new HttpHandler.Builder()
                                .setUri(wcsUrl)
                                .setPath(wcsInboundTaskApplyPath)
                                .setJson(JSON.toJSONString(hashMap))
                                .build()
                                .doPost();
                        JSONObject jsonObject = JSON.parseObject(response);

                        if (jsonObject.getInteger("code").equals(200)) {
                            bool = true;
//                        taskWrk.setStatus(TaskStatusType.DISTRIBUTE.id);//派发状态
                            taskWrk.setAssignTime(new Date());//派发时间
                            taskWrk.setWrkSts(3);//工作状态 3.成功下发入库任务给RCS
                            taskWrk.setModiTime(new Date());
                            taskWrk.setModiUser(9988L);
                        }
                    } catch (Exception e) {
                    } finally {
                        apiLogService.save("wcs派发入库任务给RCS"
                                , wcsUrl + wcsInboundTaskApplyPath
                                , null
                                , "127.0.0.1"
                                , JSON.toJSONString(hashMap)
                                , response
                                , bool
                        );
                    }
                }


            }
        }
    }
@@ -419,16 +552,24 @@
     * 出库  ===>>  库位到堆垛机站
     * 2022-06-09 TQS修改，查询工作档LIST，遍历下发，防止第一个任务堵塞出库
     */
    public synchronized void locToCrnStn(CrnSlave slave) {
        List<TaskWrk> taskWrksInitial = taskWrkMapper.selectPakOut(slave.getId(), null);
        if (taskWrksInitial.size() == 0) {
            return;
        }
        for (CrnSlave.CrnStn crnStn : slave.getCrnOutStn()) {
            List<StaDesc> staDescs = staDescMapper.selectList(new EntityWrapper<StaDesc>().eq("crn_no", slave.getId()).eq("crn_stn", crnStn.getStaNo()));
            for (StaDesc staDesc : staDescs) {
                // 获取工作状态为11（生成出库ID）的出库工作档
                List<TaskWrk> taskWrks = taskWrkMapper.selectPakOut(slave.getId(), staDesc.getStnNo().toString());
    public synchronized void locToCrnStn() {
        // 根据输送线plc遍历
        for (DevpSlave devp : slaveProperties.getDevp()) {
            // 遍历入库口
            for (DevpSlave.Sta outSta : devp.getOutSta()) {
                StorageEscalationParam storageEscalationParam = new StorageEscalationParam();
                // 获取入库站信息
                DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
                StaProtocol staProtocol = devpThread.getStation().get(outSta.getStaNo());
                if (staProtocol == null) {
                    continue;
                } else {
                    staProtocol = staProtocol.clone();
                }
                List<TaskWrk> taskWrks = taskWrkMapper.selectPakOut(1, staProtocol.getSiteId().toString());
                if (taskWrks.size() == 0) {
                    continue;
                }
                for (TaskWrk taskWrk : taskWrks) {
                    if (taskWrk == null) {
                        continue;
@@ -444,19 +585,10 @@
                    //预留


                    // 获取堆垛机出库站信息
                    SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, crnStn.getDevpPlcId());
                    StaProtocol staProtocol = devpThread.getStation().get(crnStn.getStaNo());
                    if (staProtocol == null) {
                        break;
                    } else {
                        staProtocol = staProtocol.clone();
                    }

                    // 查询站点详细信息
                    BasDevp staDetl = basDevpService.selectById(crnStn.getStaNo());
                    BasDevp staDetl = basDevpService.selectById(staProtocol.getSiteId());
                    if (staDetl == null) {
                        log.error("出库 ===>> 堆垛机站点在数据库不存在, 站点编号={}", crnStn.getStaNo());
                        log.error("出库 ===>> 堆垛机站点在数据库不存在, 站点编号={}", staProtocol.getSiteId());
                        break;
                    }

@@ -464,44 +596,35 @@
                    if (staProtocol.isAutoing() && !staProtocol.isLoading() && staDetl.getCanouting() != null && staDetl.getCanouting().equals("Y")
                            && staProtocol.getWorkNo() == 0 && staProtocol.isOutEnable()) {
                        // 命令下发区 --------------------------------------------------------------------------

                        // 已经存在吊车执行任务时，则过滤
                        if (taskWrkMapper.selectCrnWorking(slave.getId()) != null) {
                            break;
                        }

                        String mbz = taskWrk.getTargetPoint().substring(5);

                        HashMap<String, Object> hashMap = new HashMap<>();
                        hashMap.put("taskNo", taskWrk.getTaskNo());//wms任务号
                        hashMap.put("sourceStaNo", staDetl.getDevNo());//源站点
                        hashMap.put("staNo", Integer.parseInt(mbz) + "");//目标站
                        hashMap.put("locNo", taskWrk.getTargetPoint());//目标库位
                        hashMap.put("sourceLocNo", taskWrk.getOriginStartPoint());//源库位
                        hashMap.put("staNo", taskWrk.getTargetPoint());//目标站
                        String response = "";
                        Boolean bool = false;
                        try {
                            //开始上报,出库任务开始时，WCS回调WMS
                            response = new HttpHandler.Builder()
                                    .setUri(wcsUrl)
                                    .setPath(wcsInboundTaskApplyPath)
                                    .setPath(outboundTaskRequest)
                                    .setJson(JSON.toJSONString(hashMap))
                                    .build()
                                    .doPost();
                            JSONObject jsonObject = JSON.parseObject(response);

                            if (jsonObject.get("code").equals(200)) {
                            if (jsonObject.getInteger("code").equals(200)) {
                                bool = true;
//                        taskWrk.setStatus(TaskStatusType.DISTRIBUTE.id);//派发状态
                                taskWrk.setAssignTime(new Date());//派发时间
                                taskWrk.setWrkSts(3);//工作状态 3.成功下发入库任务给RCS
                                taskWrk.setCrnNo(staDesc.getCrnNo());//堆垛机号
                                taskWrk.setWrkSts(12);//工作状态 12.成功下发出库任务
                                taskWrk.setModiTime(new Date());
                                taskWrk.setModiUser(9988L);
                                taskWrkService.updateById(taskWrk);
                            }
                        } catch (Exception e) {
                        } finally {
                            apiLogService.save("wcs派发出库任务给RCS"
                                    , wcsUrl + wcsInboundTaskApplyPath
                                    , wcsUrl + outboundTaskRequest
                                    , null
                                    , "127.0.0.1"
                                    , JSON.toJSONString(hashMap)
@@ -509,47 +632,6 @@
                                    , bool
                            );
                        }

                        try {
                            // 修改工作档状态 11.生成出库ID => 12.吊车出库中
                            Date now = new Date();
                            taskWrk.setWrkSts(12);
                            taskWrk.setModiTime(now);
                            if (taskWrkMapper.updateById(taskWrk) == 0) {
                                log.error("修改工作档状态 11.生成出库ID => 12.吊车出库中 失败！！，工作号={}", taskWrk.getWrkNo());
                            }
                        } catch (Exception e) {
                            log.error("修改工作档状态 11.生成出库ID => 12.吊车出库中 失败！！，工作号={}", taskWrk.getWrkNo());
                            log.error("修改工作档状态 11.生成出库ID => 12.吊车出库中 失败！！，异常：" + e);
                        }
//                            try {
//                                HashMap<String, Object> headParam = new HashMap<>();
//                                headParam.put("taskNo", taskWrk.getTaskNo());
//                                headParam.put("status", taskWrk.getStatus());
//                                headParam.put("ioType", taskWrk.getIoType());
//                                headParam.put("barcode", taskWrk.getBarcode());
//                                String response;
//                                response = new HttpHandler.Builder()
//                                        // .setHeaders(headParam)
//                                        .setUri(wmsUrl)
//                                        .setPath(taskStatusFeedbackPath)
//                                        .setJson(JSON.toJSONString(headParam))
//                                        .build()
//                                        .doPost();
//                                JSONObject jsonObject = JSON.parseObject(response);
//                                apiLogService.save("wcs派发出库任务上报wms"
//                                        , wmsUrl + taskStatusFeedbackPath
//                                        , null
//                                        , "127.0.0.1"
//                                        , JSON.toJSONString(headParam)
//                                        , response
//                                        , true
//                                );
//                            } catch (Exception e) {
//                                log.error("wcs派发出库任务上报wms失败", JSON.toJSONString(taskWrk));
////                                throw new CoolException("wcs派发入库任务上报wms失败");
//                            }

                    }
                }
            }
@@ -557,99 +639,117 @@
    }

    /**
     * 库位移转
     * 拣料、并板、盘点再入库
     */
    public synchronized void locToLoc(CrnSlave slave, CrnProtocol crnProtocol) {
        for (CrnSlave.CrnStn crnStn : slave.getCrnOutStn()) {
            // 获取工作状态为11（生成出库ID）的移库工作档
            List<TaskWrk> taskWrks = taskWrkMapper.selectList(new EntityWrapper<TaskWrk>()
                    .eq("crn_no", slave.getId())
                    .eq("wrk_sts", 11)
                    .eq("io_type", 3)
                    .orderBy("io_pri", false));
            for (TaskWrk taskWrk : taskWrks) {

                // 双深库位且浅库位有货，则需先对浅库位进行库位移转
//                if (Utils.isDeepLoc(slaveProperties, taskWrk.getStartPoint())) {
//                    String shallowLocNo = Utils.getShallowLoc(slaveProperties, taskWrk.getStartPoint());
//                    TaskWrk hallowLocNoTask = taskWrkMapper.selectByStartPoint(shallowLocNo);
//                    if (!Cools.isEmpty(hallowLocNoTask)){
//                        continue;
//                    }
//                }
                // 堆垛机控制过滤
                if (!crnProtocol.getStatusType().equals(CrnStatusType.IDLE) || crnProtocol.getTaskNo() != 0) {
    public synchronized void stnToCrnStnPick(Integer mark) {
        for (DevpSlave devp : slaveProperties.getDevp()) {
            // 遍历拣料入库口
            for (DevpSlave.Sta pickSta : devp.getPickSta()) {
                StorageEscalationParam storageEscalationParam = new StorageEscalationParam();
                // 获取拣料入库站信息
                SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
                StaProtocol staProtocol = devpThread.getStation().get(pickSta.getStaNo());
                if (staProtocol == null) {
                    continue;
                }

                // 已经存在吊车执行任务时，则过滤
                if (taskWrkMapper.selectCrnWorking(slave.getId()) != null) {
                    continue;
                }

                if (taskWrk == null || Cools.isEmpty(taskWrk.getTargetPoint()) || taskWrk.getTargetPoint().equals("") || taskWrk.getWrkNo() == null) {
                    continue;
                }
                // 工作档状态判断
                if (taskWrk.getIoType() != 3 || taskWrk.getTargetPoint() == null) {
                    log.error("查询工作档数据不符合条件--入出类型/目标库位号, 工作号={}，源库位={}，入出类型={}", taskWrk.getWrkNo(), taskWrk.getTargetPoint(), taskWrk.getIoType());
                    continue;
                }

                // 命令下发区 --------------------------------------------------------------------------


                // 1.堆垛机开始移动
                CrnCommand crnCommand = new CrnCommand();
                crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
                crnCommand.setTaskNo(taskWrk.getWrkNo().shortValue()); // 工作号
                crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式:  库位移转
                crnCommand.setSourcePosX(Utils.getRowShort(taskWrk.getStartPoint()));     // 源库位排
                crnCommand.setSourcePosY(Utils.getBayShort(taskWrk.getStartPoint()));     // 源库位列
                crnCommand.setSourcePosZ(Utils.getLevShort(taskWrk.getStartPoint()));     // 源库位层
                crnCommand.setDestinationPosX(Utils.getRowShort(taskWrk.getTargetPoint()));     // 目标库位排
                crnCommand.setDestinationPosY(Utils.getBayShort(taskWrk.getTargetPoint()));     // 目标库位列
                crnCommand.setDestinationPosZ(Utils.getLevShort(taskWrk.getTargetPoint()));     // 目标库位层
                crnCommand.setCommand((short) 1);
                if (!CommandUtils.offer(SlaveType.Crn, taskWrk.getCrnNo(), new Task(2, crnCommand), false)) {
                    log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", taskWrk.getCrnNo(), JSON.toJSON(crnCommand));
                } else {
                    // 修改工作档状态 11.生成出库ID => 12.吊车出库中
                    Date now = new Date();
                    taskWrk.setWrkSts(12);
                    taskWrk.setStatus(2);
                    taskWrk.setModiTime(now);
                    if (taskWrkMapper.updateById(taskWrk) == 0) {
                        log.error("修改工作档状态 11.生成出库ID => 12.吊车出库中 失败！！，工作号={}", taskWrk.getWrkNo());
                    }
                    staProtocol = staProtocol.clone();
                }

                if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.isInEnable() && staProtocol.isPakMk()
                        && staProtocol.getWorkNo() >= 3001 && staProtocol.getWorkNo() <= 6000) {

                    storageEscalationParam.setTaskNo(Integer.valueOf(staProtocol.getWorkNo()));
                    String response = "";
                    Boolean success = false;
                    try {
                        HashMap<String, Object> headParam = new HashMap<>();
                        headParam.put("TaskNo", taskWrk.getTaskNo());
                        String response;
                        //开始上报,拣料、并板、盘点再入库，WCS回调WMS
                        response = new HttpHandler.Builder()
                                // .setHeaders(headParam)
                                .setUri(wmsUrl)
                                .setPath(taskStatusFeedbackPath)
                                .setJson(JSON.toJSONString(headParam))
                                .setPath(returnWarehouse)
                                .setJson(JSON.toJSONString(storageEscalationParam))
                                .build()
                                .doPost();
                        JSONObject jsonObject = JSON.parseObject(response);
                        apiLogService.save("wcs派发移库任务上报wms"
                                , wmsUrl + taskStatusFeedbackPath
                        if (!Cools.isEmpty(response) && !Cools.isEmpty(jsonObject.get("returnStatus")) && jsonObject.get("returnStatus").equals(0) && !Cools.isEmpty(jsonObject.get("results").toString())) {
                            Result result = JSON.parseObject(jsonObject.get("results").toString(), Result.class);
                            // 创新一个入库工作档
                            TaskWrk taskWrk = taskWrkService.selectByTaskNo(result.getTaskNo() + "");
                            if (Cools.isEmpty(taskWrk)) {
                                taskWrk = createTask1(result, result.getBarcode(), staProtocol.getSiteId());
                                if (Cools.isEmpty(taskWrk)) {
                                    log.error("库位异常，库位号：={}", taskWrk.getOriginTargetPoint());
                                } else {
                                    taskWrkService.insert(taskWrk);
                                    StaDesc staDesc = staDescService.selectOne(new EntityWrapper<StaDesc>()
                                            .eq("crn_no", taskWrk.getCrnNo()).eq("type_no", 1).eq("stn_no", staProtocol.getSiteId()));
                                    HashMap<String, Object> hashMap = new HashMap<>();
                                    hashMap.put("TaskNo", taskWrk.getTaskNo());
                                    Boolean bool = false;

                                    staProtocol.setWorkNo(taskWrk.getWrkNo().shortValue());
                                    staProtocol.setStaNo((short) 0);
                                    MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));

                                    try {
                                        //开始上报,任务开始时，WCS回调WMS
                                        response = new HttpHandler.Builder()
                                                .setUri(wmsUrl)
                                                .setPath(taskStatusFeedbackPath)
                                                .setJson(JSON.toJSONString(hashMap))
                                                .build()
                                                .doPost();
                                        JSONObject jsonObject1 = JSON.parseObject(response);
                                        if (jsonObject1.get("ReturnStatus").equals(0)) {
                                            bool = true;

                                        }

                                    } catch (Exception e) {

                                    } finally {
                                        apiLogService.save("wcs拣料、并板、盘点再入库上报wms"
                                                , wmsUrl + TaskExecCallback
                                                , null
                                                , "127.0.0.1"
                                                , JSON.toJSONString(hashMap)
                                                , response
                                                , bool
                                        );
                                    }
                                }
                            }
                        }
                    } catch (Exception e) {
                    } finally {
                        apiLogService.save("wcs派发出库任务给RCS"
                                , wcsUrl + outboundTaskRequest
                                , null
                                , "127.0.0.1"
                                , JSON.toJSONString(headParam)
                                , JSON.toJSONString(storageEscalationParam)
                                , response
                                , true
                                , success
                        );
                    } catch (Exception e) {
                        log.error("wcs派发移库库任务上报wms失败", taskWrk);
//                        throw new CoolException("wcs派发移库库任务上报wms失败");
                    }

                }
                return;

            }
        }
    }

    public void scanForkLift() {
        for (int i = 1; i <= 2; i++) {
            Object object = redisUtil.get("fork_lift_put_complete_" + i);
            if(object != null) {
                String taskNo = object.toString();
                TaskWrk taskWrk = taskWrkService.selectByTaskNo(taskNo);//wms任务号
                if (taskWrk == null) {
                    log.info("没有找到该任务");
                }else{
                    log.info("提前完成出库任务={}", taskWrk);
                    taskWrkService.taskComplete(taskWrk);
                    redisUtil.del("fork_lift_put_complete_" + i);
                }
            }
        }

@@ -1089,19 +1189,20 @@
        return response;
    }

    private TaskWrk createTask1(Result result, String barcode,Integer devNo) {
    private TaskWrk createTask1(Result result, String barcode, Integer devNo) {
        Date now = new Date();
        TaskWrk taskWrk = new TaskWrk();
//        int workNo1 = commonService.getWorkNo(WorkNoType.PAKIN.type);//获取入库工作号
        taskWrk.setTaskNo(result.getTaskNo()+"");//任务号
        taskWrk.setTaskNo(result.getTaskNo() + "");//任务号
        taskWrk.setWrkNo(result.getTaskNo());
        taskWrk.setStatus(TaskStatusType.DISTRIBUTE.id);//任务状态：派发
        taskWrk.setCreateTime(now);
        taskWrk.setIoType(1);//任务类型
        taskWrk.setIoPri(13);//优先级
        taskWrk.setWrkSts(2);//2.派发入库任务给RCS
        taskWrk.setBarcode(barcode);//条码
        taskWrk.setTargetPoint(devNo+"");//站点终点
        taskWrk.setStartPoint(devNo+"");//站点起点
        taskWrk.setTargetPoint(devNo + result.getShelfUnitId().substring(6));//站点终点
        taskWrk.setStartPoint(devNo + "");//站点起点
        taskWrk.setOriginStartPoint("");//源库位
        taskWrk.setOriginTargetPoint(result.getShelfUnitId());//目标库位
        return taskWrk;