#

whycq

2024-01-31 b3b9b700ca5121dd0f9472df2e1527ed5f47e887

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

@@ -5,13 +5,18 @@
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.core.common.Cools;
import com.core.exception.CoolException;
import com.zy.asrs.controller.CrnController;
import com.zy.asrs.controller.OpenController;
import com.zy.asrs.domain.enums.TaskStatusType;
import com.zy.asrs.domain.enums.WorkNoType;
import com.zy.asrs.domain.param.CrnOperatorParam;
import com.zy.asrs.entity.*;
import com.zy.asrs.entity.param.TaskOverToWms;
import com.zy.asrs.mapper.*;
import com.zy.asrs.service.*;
import com.zy.asrs.utils.CommandUtils;
import com.zy.asrs.utils.Utils;
import com.zy.common.service.CommonService;
import com.zy.common.utils.HttpHandler;
import com.zy.core.CrnThread;
import com.zy.core.DevpThread;
@@ -83,6 +88,8 @@

    @Autowired
    private ApiLogService apiLogService;
    @Autowired
    private CommonService commonService;

    @Value("${wms.url}")
    private String wmsUrl;
@@ -90,6 +97,10 @@
    private String inboundTaskApplyPath;
    @Value("${wms.movePath}")
    private String movePath;
    @Value("${wms.taskStatusFeedbackPath}")
    private String taskStatusFeedbackPath;
    @Autowired
    private CrnController crnController;


    public void generateStoreWrkFile() throws IOException, InterruptedException {
@@ -179,9 +190,16 @@
                        if(!Cools.isEmpty(barcode)) {
                            // 请求wms接口，获取工作号和目标库位
                            ToWmsDTO toWmsDTO = new ToWmsDTO(barcode,staProtocol.getSiteId(),staProtocol.isHigh() ? 2 : 1);
                            TaskWrk taskWrk1=taskWrkService.selectOne(new EntityWrapper<TaskWrk>().eq("barcode",barcode));
                            if(!Cools.isEmpty(taskWrk1)){
                                log.info("托盘码："+barcode+"任务档存在");
                                continue;
                            }
                            HashMap<String, Object> headParam = new HashMap<>();
                            headParam.put("Content-Type","application/json");
                            String response;
                            response = new HttpHandler.Builder()
                                    .setHeaders(null)
                                   // .setHeaders(headParam)
                                    .setUri(wmsUrl)
                                    .setPath(inboundTaskApplyPath)
                                    .setJson(JSON.toJSONString(toWmsDTO))
@@ -197,10 +215,11 @@
                                    ,response
                                    ,true
                            );
                            log.info("入库请求参数{}" + JSON.toJSONString(toWmsDTO));
                            if (jsonObject.getInteger("code").equals(200) && !Cools.isEmpty(jsonObject.get("data").toString())) {
                                GetWmsDto getWmsDto = JSON.parseObject(jsonObject.get("data").toString(), GetWmsDto.class);
                                // 创新一个入库工作档
                                TaskWrk taskWrk = taskWrkService.selectByTaskNo(getWmsDto.getTaskNo());
                                TaskWrk taskWrk = taskWrkService.selectByTaskNo(getWmsDto.getWrkNo());
                                if(Cools.isEmpty(taskWrk)) {
                                    taskWrk = createTask(getWmsDto,barcode);
                                    if (Cools.isEmpty(taskWrk)){
@@ -208,7 +227,7 @@
                                    }else {
                                        taskWrkService.insert(taskWrk);
                                        StaDesc staDesc = staDescService.selectOne(new EntityWrapper<StaDesc>()
                                                .eq("crn_no", taskWrk.getCrnNo()).eq("type_no",1).eq("stn_no",staProtocol.getStaNo().intValue()));
                                                .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));
@@ -447,6 +466,7 @@
                if (!flag) {
                    continue;
                }

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

                int workNo = commonService.getWorkNo(WorkNoType.PAKIN.type);//获取入库工作号
                taskWrk.setWrkNo(workNo);//工作号
                taskWrk.setStatus(TaskStatusType.DISTRIBUTE.id);//派发状态
                taskWrk.setAssignTime(new Date());//派发时间
                taskWrk.setWrkSts(3);//工作状态 3.吊车入库
                taskWrk.setCrnNo(staDesc.getCrnNo());//堆垛机号
                taskWrk.setModiTime(new Date());
                taskWrk.setModiUser(9988L);
                taskWrkService.updateById(taskWrk);

//                //取出命令
//                List<CommandInfo> commandInfos = commandInfoService.selectByTaskNo(taskWrk.getTaskNo());
@@ -496,27 +526,49 @@

                // 命令下发区 --------------------------------------------------------------------------
                CrnCommand crnCommand = new CrnCommand();
                crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
                crnCommand.setCrnNo(staDesc.getCrnNo()); // 堆垛机编号
                crnCommand.setTaskNo(taskWrk.getWrkNo().shortValue()); // 工作号
                crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式:  库位移转
                crnCommand.setSourcePosX(crnStn.getBay().shortValue());     // 源库位列
                crnCommand.setSourcePosY(crnStn.getLev().shortValue());     // 源库位层
                crnCommand.setSourcePosZ(crnStn.getRow().shortValue());     // 源库位排
                crnCommand.setDestinationPosX(Utils.getBayShort(taskWrk.getTargetPoint()));     // 目标库位列
                crnCommand.setDestinationPosY(Utils.getLevShort(taskWrk.getTargetPoint()));     // 目标库位层
                crnCommand.setDestinationPosZ(Utils.getRowShort(taskWrk.getTargetPoint()));     // 目标库位排
                crnCommand.setSourcePosX(crnStn.getRow().shortValue());     // 源库位列
                crnCommand.setSourcePosY(crnStn.getBay().shortValue());     // 源库位层
                crnCommand.setSourcePosZ(crnStn.getLev().shortValue());     // 源库位排
                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))) {
                    log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", taskWrk.getCrnNo(), JSON.toJSON(crnCommand));
                } else {
                    // 修改工作档状态 2.设备上走 => 3.吊车入库中
                    Date now = new Date();
                    taskWrk.setWrkSts(3);
                    taskWrk.setModiTime(now);
                    if (taskWrkMapper.updateById(taskWrk) == 0) {
                        log.error("修改工作档状态 2.设备上走 => 3.吊车入库中 失败！！，工作号={}", taskWrk.getWrkNo());
                if (!CommandUtils.offer(SlaveType.Crn, taskWrk.getCrnNo(), new Task(2, crnCommand),false)) {
                    log.error("堆垛机命令生成失败，堆垛机号={}，任务数据={}", taskWrk.getCrnNo(), JSON.toJSON(crnCommand));
                    throw new CoolException("堆垛机命令生成失败");
                }else{
                    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失败", taskWrk);
                        throw new CoolException("wcs派发入库任务上报wms失败");
                    }

                }
            }

@@ -578,59 +630,108 @@
                            break;
                        }

                        // 双深库位且浅库位有货，则需先对浅库位进行库位移转
                        if (Utils.isDeepLoc(slaveProperties, taskWrk.getStartPoint())) {

                            taskWrkMapper.selectPakOutIoType(taskWrk.getCrnNo());
                        // 修改工作档状态 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());
                        }
                        CrnCommand command = new CrnCommand();
                        command.setCrnNo(taskWrk.getCrnNo()); // 堆垛机编号
                        command.setTaskNo(taskWrk.getWrkNo().shortValue()); // 工作号
                        command.setAckFinish((short) 0);  // 任务完成确认位
                        command.setTaskMode(CrnTaskModeType.PAKIN); // 任务模式
                        command.setSourcePosX(Utils.getRowShort(taskWrk.getStartPoint()));     // 源库位排
                        command.setSourcePosY(Utils.getBayShort(taskWrk.getStartPoint()));     // 源库位列
                        command.setSourcePosZ(Utils.getLevShort(taskWrk.getStartPoint()));     // 源库位层
                        command.setDestinationPosX(crnStn.getRow().shortValue());     // 目标库位排
                        command.setDestinationPosY(crnStn.getBay().shortValue());     // 目标库位列
                        command.setDestinationPosZ(crnStn.getLev().shortValue());     // 目标库位层
                        command.setCommand((short)1);
                        if (!CommandUtils.offer(SlaveType.Crn, taskWrk.getCrnNo(), new Task(2, command),false)) {
                            log.error("堆垛机命令生成失败，堆垛机号={}，任务数据={}", taskWrk.getCrnNo(), JSON.toJSON(command));
                            throw new CoolException("堆垛机命令生成失败");
                        }else{
                            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失败", taskWrk);
                                throw new CoolException("wcs派发入库任务上报wms失败");
                            }

                            List<TaskWrk> taskWrks1 = taskWrkMapper.selectPakOutIoType(taskWrk.getCrnNo());
                            if (Cools.isEmpty(taskWrks1) && taskWrks1.size()!=0){
                                continue;
                            }
                            String shallowLocNo = Utils.getShallowLoc(slaveProperties, taskWrk.getStartPoint());
                            TaskWrk hallowLocNoTask = taskWrkMapper.selectByStartPoint(shallowLocNo);
                            if (!Cools.isEmpty(hallowLocNoTask)){
                                continue;
                            }
                        }

                        //取出命令
                        List<CommandInfo> commandInfos = commandInfoService.selectByTaskNo(taskWrk.getTaskNo());
                        Integer commandStep = taskWrk.getCommandStep();
                        if (commandInfos.isEmpty()) {
                            continue;//命令空
                        }

                        //判断末端命令是否执行
                        CommandInfo commandInfo2 = commandInfos.get(commandInfos.size() - 1);
                        if (commandInfo2.getCommandStatus() != CommandStatusType.CREATE.id) {
                            continue;//指令已执行
                        }

                        CommandInfo commandInfo = commandInfos.get(commandStep);
                        CommandPackage commandPackage = JSON.parseObject(commandInfo.getCommand(), CommandPackage.class);//取出命令报文
                        CrnCommand crnCommand = JSON.parseObject(commandPackage.getCommand().toString(), CrnCommand.class);

                        if (!MessageQueue.offer(SlaveType.Crn, taskWrk.getCrnNo(), new Task(2, crnCommand))) {
                            log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", taskWrk.getCrnNo(), JSON.toJSON(crnCommand));
                        } else {
                            // 修改工作档状态 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());
                            }
                            //开始运行
                            String response = CrnStartRunning(taskWrk);
                            JSONObject jsonObject = JSON.parseObject(response);
                            if (jsonObject.getInteger("code").equals(200)) {

                            }else {
                                log.error("出库开始运行通讯失败,"+jsonObject.get("msg"));

                            }
                        }
//                        // 双深库位且浅库位有货，则需先对浅库位进行库位移转
//                        if (Utils.isDeepLoc(slaveProperties, taskWrk.getStartPoint())) {
//
//                            taskWrkMapper.selectPakOutIoType(taskWrk.getCrnNo());
//
//                            List<TaskWrk> taskWrks1 = taskWrkMapper.selectPakOutIoType(taskWrk.getCrnNo());
//                            if (Cools.isEmpty(taskWrks1) && taskWrks1.size()!=0){
//                                continue;
//                            }
//                            String shallowLocNo = Utils.getShallowLoc(slaveProperties, taskWrk.getStartPoint());
//                            TaskWrk hallowLocNoTask = taskWrkMapper.selectByStartPoint(shallowLocNo);
//                            if (!Cools.isEmpty(hallowLocNoTask)){
//                                continue;
//                            }
//                        }
//
//                        //取出命令
//                        List<CommandInfo> commandInfos = commandInfoService.selectByTaskNo(taskWrk.getTaskNo());
//                        Integer commandStep = taskWrk.getCommandStep();
//                        if (commandInfos.isEmpty()) {
//                            continue;//命令空
//                        }
//
//                        //判断末端命令是否执行
//                        CommandInfo commandInfo2 = commandInfos.get(commandInfos.size() - 1);
//                        if (commandInfo2.getCommandStatus() != CommandStatusType.CREATE.id) {
//                            continue;//指令已执行
//                        }
//
//                        CommandInfo commandInfo = commandInfos.get(commandStep);
//                        CommandPackage commandPackage = JSON.parseObject(commandInfo.getCommand(), CommandPackage.class);//取出命令报文
//                        CrnCommand crnCommand = JSON.parseObject(commandPackage.getCommand().toString(), CrnCommand.class);
//
//                        if (!MessageQueue.offer(SlaveType.Crn, taskWrk.getCrnNo(), new Task(2, crnCommand))) {
//                            log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", taskWrk.getCrnNo(), JSON.toJSON(crnCommand));
//                        } else {
//
//                            //开始运行
//                            String response = CrnStartRunning(taskWrk);
//                            JSONObject jsonObject = JSON.parseObject(response);
//                            if (jsonObject.getInteger("code").equals(200)) {
//
//                            }else {
//                                log.error("出库开始运行通讯失败,"+jsonObject.get("msg"));
//
//                            }
//                        }

                    }
                }
@@ -810,42 +911,98 @@
    /**
     * 执行对工作档的完成操作
     */
    public void storeFinished() {
    public void storeFinished() throws InterruptedException {
        for (CrnSlave crn : slaveProperties.getCrn()) {
            // 获取堆垛机信息
            CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crn.getId());
            CrnProtocol crnProtocol = crnThread.getCrnProtocol();
            if (crnProtocol == null) { continue; }

            //  状态：等待确认 并且  任务完成位 = 1
            if (crnProtocol.getTaskFinish() == 0 && crnProtocol.statusType == CrnStatusType.HANDLING_COMPLETED && crnProtocol.getTaskNo() != 0) {
                // 获取入库待确认工作档
                //获取入库待确认工作档
                TaskWrk taskWrk = taskWrkMapper.selectCrnNoInWorking(crn.getId(),crnProtocol.getTaskNo().intValue());
                if (Cools.isEmpty(taskWrk)) {
                if (Cools.isEmpty(taskWrk)&&crnProtocol.getTaskNo() !=999) {
                    log.error("堆垛机处于等待确认且任务完成状态，但未找到工作档。堆垛机号={}，工作号={}", crn.getId(), crnProtocol.getTaskNo());
                    continue;
                }
                // 入库 + 库位转移  ==> 4.入库完成
                if ((taskWrk.getWrkSts() == 3 && taskWrk.getIoType() == 1) || (taskWrk.getWrkSts() == 12 && taskWrk.getIoType() == 3)) {
                    taskWrk.setWrkSts(4);
                } else {
                    continue;
                }
                Date now = new Date();
                taskWrk.setModiTime(now);
                Integer integerTaskWrk = taskWrkMapper.updateById(taskWrk);
                // 修改成功后复位堆垛机
                if (integerTaskWrk > 0) {
                    // 堆垛机复位
                    crnThread.setResetFlag(true);
                Thread.sleep(300);
                //确认完成信号
                CrnOperatorParam crnOperatorParam=new CrnOperatorParam();
                crnOperatorParam.setCrnNo(crn.getId());

                    //更新库位状态
                    LocMast locMast = locMastService.selectByLocNo(taskWrk.getTargetPoint());
                    locMast.setLocSts("F");//F.在库
                    locMast.setBarcode(taskWrk.getBarcode());//托盘码
                    locMast.setModiTime(now);
                    locMast.setModiUser(9999L);
                    locMastService.updateById(locMast);
                crnController.crnTaskComplete(crnOperatorParam);
                if(!Cools.isEmpty(taskWrk)){
                    if(taskWrk.getIoType()==1){
                        taskWrk.setWrkSts(4);//入库完成
                        taskWrk.setStatus(5);//完结
                        //更新库位状态
                        LocMast locMast = locMastService.selectByLocNo(taskWrk.getTargetPoint());
                        locMast.setLocSts("F");//F.在库
                        locMast.setBarcode(taskWrk.getBarcode());//托盘码
                        locMast.setModiTime(new Date());
                        locMast.setModiUser(9999L);
                        locMastService.updateById(locMast);
                    }else if(taskWrk.getIoType()==2){
                        taskWrk.setWrkSts(14);//出库完成
                        taskWrk.setStatus(5);//完结
                        //更新库位状态
                        LocMast locMast = locMastService.selectByLocNo(taskWrk.getStartPoint());
                        locMast.setLocSts("O");//O.空库位
                        locMast.setBarcode("");//托盘码
                        locMast.setModiTime(new Date());
                        locMast.setModiUser(9999L);
                        locMastService.updateById(locMast);
                    }else if(taskWrk.getIoType()==3){
                        taskWrk.setWrkSts(4);//入库完成
                        taskWrk.setStatus(5);//完结
                        //更新库位状态
                        LocMast locMast = locMastService.selectByLocNo(taskWrk.getTargetPoint());
                        locMast.setLocSts("F");//F.在库
                        locMast.setBarcode(taskWrk.getBarcode());//托盘码
                        locMast.setModiTime(new Date());
                        locMast.setModiUser(9999L);
                        locMastService.updateById(locMast);

                        LocMast locMast1 = locMastService.selectByLocNo(taskWrk.getStartPoint());
                        locMast1.setLocSts("O");//O.空库位
                        locMast1.setBarcode("");//托盘码
                        locMast1.setModiTime(new Date());
                        locMast1.setModiUser(9999L);
                        locMastService.updateById(locMast1);
                    }
                    taskWrkService.updateById(taskWrk);


                    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失败", taskWrk);
                        throw new CoolException("wcs派发入库任务上报wms失败");
                    }
                }

            }
        }
    }
@@ -980,6 +1137,7 @@
        }

        for (TaskWrk taskWrk : taskWrkService.selectReceive()) {

            try {
                taskWrkService.distribute(taskWrk.getTaskNo(), 9527L);
            } catch (CoolException e) {
@@ -1110,7 +1268,9 @@
        }
        Date now = new Date();
        TaskWrk taskWrk = new TaskWrk();
        int workNo1 = commonService.getWorkNo(WorkNoType.PAKIN.type);//获取入库工作号
        taskWrk.setTaskNo(dto.getWrkNo());//任务号
        taskWrk.setWrkNo(workNo1);
        taskWrk.setStatus(TaskStatusType.RECEIVE.id);//任务状态：接收
        taskWrk.setCreateTime(now);
        taskWrk.setIoType(1);//任务类型