优化

imcs-admin-boot/imcs-business-biz/src/main/java/com/github/zuihou/business/DemoLine/DemoLineConstant.java

@@ -40,7 +40,7 @@ public interface DemoLineConstant {
     // 示范线配置
 //    String DEMOLINE_RJQR_ZS = "123";
     // 柔性线配置
-    String DEMOLINE_RJQR_ZS = "30";
+    String DEMOLINE_RJQR_ZS = "200";
     String DEMOLINE_RJQR_SIX = "900";
 
     String DEMOLINE_RJQR_KW1 = "126";

imcs-admin-boot/imcs-business-biz/src/main/java/com/github/zuihou/business/mq/TaskWorkNode.java

@@ -189,15 +189,6 @@ public class TaskWorkNode {
 
     public void updateTaskStatusJob(String data, String consumerQueue) throws InterruptedException {
 
-        /*//判断是否存在换手抓操作
-        Object changeHandOp = msgUtil.redis_get("CHANGE_HAND_OP"); //换手抓标识
-        if(!Objects.isNull(changeHandOp) && "2".equals(changeHandOp.toString())){
-            logger.info("当前机器人正在换手抓，不执行MQ方法体");
-            Thread.sleep(3000); //等待三秒
-            throw new InterruptedException("设备资源不通过，消息重新进入队尾");
-        }
-*/
-
         Date startTime = new Date(); //记录开始时间
         String returnData = "";
         boolean specialCallBackMyselfFlag = false;
@@ -216,439 +207,391 @@ public class TaskWorkNode {
         //业务类型-1、是普通的节点类型，2-是线边库轮询 6-刀具节点类型的节点类型
         String bizType = jsonObject.getString("bizType");
 
-        if("6".equals(bizType)){
-
-            String takePhotoFlag = jsonObject.getString("takePhotoFlag");
-
-            //当前节点为刀具任务
-            ToolTaskExecute toolTaskExecute = toolTaskExecuteService.getOne(new QueryWrap<ToolTaskExecute>().lambda().eq(ToolTaskExecute::getToolTaskNodeId,taskNodeId));
-
-            if(toolTaskExecute == null){
-                return;
-            }
+        taskNode = taskNodeService.getById(taskNodeId);
 
-            if(toolTaskExecute.getIsSend() !=null && toolTaskExecute.getIsSend() == 1){
-                logger.warn("刀具节点{}已下发，重复丢弃",toolTaskExecute.getId());
-                return;
-            }
+        if(null == taskNode){
+            return;
+        }
 
-            ToolNodeOperationService toolNodeOperationService = MsgUtil.getBean(ToolRobotNodeServiceImpl.class);
-            if (jsonObject.containsKey(toolTaskExecute.getId() + "count")) {
-                conMap.put(toolTaskExecute.getId() + "count", jsonObject.getString(toolTaskExecute.getId() + "count"));
-            }
-            toolNodeOperationService.checkCondition(toolTaskExecute,conMap);
-        }else{
-
-            //判断是否存在刀具优先执行标识
-            Object toolPriorityExecute = msgUtil.redis_get("TOOL_PRIORITY_EXECUTE");//刀具优先执行标识
-            if(!Objects.isNull(toolPriorityExecute) && "2".equals(toolPriorityExecute.toString())){
-                logger.info("存在刀具优先执行标识");
-                throw new InterruptedException("存在刀具优先执行标识，消息重新进入队尾");
+        // add by yejian on 20220726 使用完成后释放redis资源
+        if(taskNode.getCompleteBatchSort() != 1){
+            TaskNode beforTaskNode  = taskNodeService.getNextNTaskNode(taskNode, -1);
+            // 下一工序
+            if(!beforTaskNode.getTaskId().equals(taskNode.getTaskId())){
+                List<TaskNode> operationTaskNodes = taskNodeService.list(Wraps.<TaskNode>lbQ().eq(TaskNode::getTaskId, beforTaskNode.getTaskId()));
+                List<Long> operationTaskNodeIds = operationTaskNodes.stream().map(operationTaskNode -> operationTaskNode.getId()).collect(Collectors.toList());
+                for(Long operationTaskNodeId : operationTaskNodeIds){
+                    // 清除redis里面的内容
+                    //msgUtil.redis_del(YunjianConstant.YUNJIAN_CALLBACK_PARAM + "_" + operationTaskNodeId);
+                    msgUtil.redis_del(DemoCacheKey.YUNJIAN_CAMP + "_" + YunjianConstant.YUNJIAN_JXS + operationTaskNodeId);
+                    msgUtil.redis_del(DemoCacheKey.YUNJIAN_CAMP + "_" + YunjianConstant.YUNJIAN_HCW + operationTaskNodeId);
+                    msgUtil.redis_del(DemoCacheKey.YUNJIAN_CAMP + "_" + DemoLineConstant.YUNJIAN_TARGET_XBK_FLAG + operationTaskNodeId);
+                    msgUtil.redis_del(DemoCacheKey.YUNJIAN_CAMP + "_" + DemoLineConstant.YUNJIAN_TARGET_HCW_XBK_FLAG + operationTaskNodeId);
+                    msgUtil.redis_del(DemoCacheKey.YUNJIAN_CAMP + "_" + DemoLineConstant.YUNJIAN_TARGET_STORE + operationTaskNodeId);
+                    msgUtil.redis_del(CacheKey.TASK_CURRENT_NODE + "_" +  + operationTaskNodeId);
+                }
             }
+        }
 
-            taskNode = taskNodeService.getById(taskNodeId);
+        tTask = taskMapper.selectById(taskNode.getTaskId());
+        //初始化业务日志
+        log = getBusinessLog(tTask, taskNode);
+
+        try {
+            lockFlag = lock.tryLock();
+            lockCondition = checkFlowCondition(tTask);
+            if(lockFlag){
+                logger.info("节点{}获取到了执行锁",taskNode.getId());
+                TaskNode hisTask = taskNodeMapper.selectById(taskNodeId);
+                if("3".equals(hisTask.getExeResult())){
+                    logger.warn("节点{}已经执行完成，重复推送丢弃",taskNodeId);
+                    log.setExeStatus("3").setExeResult("0").setExeResult("0").setManual("0").setFeedback("节点已经执行完成，重复推送丢弃");
+                    return;
+                }
 
-            if(null == taskNode){
-                return;
-            }
-            /*if ("04".equals(taskNode.getInterfaceType())&&!"3".equals(bizType)) {
-                //直接跳过
-            }else{
-                boolean changeFlag = this.checkRobotHand(DictionaryKey.HAND_PONIT.get("TRAY_HAND")); //更换机器人手抓标识
-                if(changeFlag){
-                    //需要更新机器人手抓
-                    msgUtil.redis_set("CHANGE_HAND_OP","2");
-                    try{
-                        this.changeRobotHand(taskNode.getTaskId(),taskNode.getId(),DictionaryKey.HAND_PONIT.get("TRAY_HAND"),DictionaryKey.CARRY_TYPE.get("TRAY_HAND"));
-                    }catch (Exception e){
-                        e.printStackTrace();
-                    }finally {
-                        //当前任务回到队尾
-                        throw new InterruptedException("需要更换托盘手抓，当前消息重新进入队尾");
+                String handMode = jsonObject.getString("handMode");
+                //多产品搬运类型
+                String carryType = jsonObject.getString("carryType");
+
+                String queueName = "device.queue."+ BizConstant.MQ_GLOBAL_EXCEPTION;
+
+                if (consumerQueue.equals(queueName)) {
+                    StringBuilder buffer = new StringBuilder();
+                    //处理产线存储
+                    String lineName = jsonObject.getString("Line");
+                    ZZone line = zoneService.getOne(new LbqWrapper<ZZone>().like(ZZone::getAbbreviate, lineName.substring(0, lineName.length()-1)));
+                    buffer.append(lineName).append("-设备(").append(jsonObject.getString("Name")+")").append(jsonObject.getString("Status"));
+                    log.setExeResult("0").setManual("1").setFeedback("全局异常:"+ buffer.toString()).setStartTime(new Date()).setExecuteTime(new Date()).setZoneId(line.getId());
+
+                    LbqWrapper<AAutoNodeLog> lbqWrapper = new LbqWrapper<AAutoNodeLog>();
+                    lbqWrapper.eq(AAutoNodeLog::getZoneId, line.getId()).eq(AAutoNodeLog::getExeResult, log.getExeResult()).eq(AAutoNodeLog::getManual, log.getManual()).eq(AAutoNodeLog::getStatus, 0).eq(AAutoNodeLog::getFeedback, log.getFeedback());
+                    //判断全局异常是否已存在
+                    AAutoNodeLog exist = autoNodeLogService.getOne(lbqWrapper);
+                    if(null == exist){
+                        autoNodeLogService.save(log);
+                    }else{
+                        //更新执行时间
+                        exist.setExecuteTime(new Date());
+                        autoNodeLogService.updateAllById(exist);
                     }
+                    //throw new RuntimeException("全局通知异常");
+                    return;
+                }
+                logger.info("=======================" + taskNodeId);
 
+                //
+                if (taskNode == null || taskNode.getTaskId() == null) {
+                    //模拟处理数据
+                    log.setExeResult("0").setManual("0").setFeedback("当前任务节点为空");
+                    autoNodeLogService.save(log);
+                    throw new RuntimeException("当前任务节点为空");
                 }
-            }*/
-
-            // add by yejian on 20220726 使用完成后释放redis资源
-            if(taskNode.getCompleteBatchSort() != 1){
-                TaskNode beforTaskNode  = taskNodeService.getNextNTaskNode(taskNode, -1);
-                // 下一工序
-                if(!beforTaskNode.getTaskId().equals(taskNode.getTaskId())){
-                    List<TaskNode> operationTaskNodes = taskNodeService.list(Wraps.<TaskNode>lbQ().eq(TaskNode::getTaskId, beforTaskNode.getTaskId()));
-                    List<Long> operationTaskNodeIds = operationTaskNodes.stream().map(operationTaskNode -> operationTaskNode.getId()).collect(Collectors.toList());
-                    for(Long operationTaskNodeId : operationTaskNodeIds){
-                        // 清除redis里面的内容
-                        //msgUtil.redis_del(YunjianConstant.YUNJIAN_CALLBACK_PARAM + "_" + operationTaskNodeId);
-                        msgUtil.redis_del(DemoCacheKey.YUNJIAN_CAMP + "_" + YunjianConstant.YUNJIAN_JXS + operationTaskNodeId);
-                        msgUtil.redis_del(DemoCacheKey.YUNJIAN_CAMP + "_" + YunjianConstant.YUNJIAN_HCW + operationTaskNodeId);
-                        msgUtil.redis_del(DemoCacheKey.YUNJIAN_CAMP + "_" + DemoLineConstant.YUNJIAN_TARGET_XBK_FLAG + operationTaskNodeId);
-                        msgUtil.redis_del(DemoCacheKey.YUNJIAN_CAMP + "_" + DemoLineConstant.YUNJIAN_TARGET_HCW_XBK_FLAG + operationTaskNodeId);
-                        msgUtil.redis_del(DemoCacheKey.YUNJIAN_CAMP + "_" + DemoLineConstant.YUNJIAN_TARGET_STORE + operationTaskNodeId);
-                        msgUtil.redis_del(CacheKey.TASK_CURRENT_NODE + "_" +  + operationTaskNodeId);
-                    }
+
+                if (tTask == null || tTask.getStatus() == "3") {
+                    log.setTaskNodeId(taskNode.getId()).setExeResult("0").setManual("0").setFeedback("当前任务为空");
+                    autoNodeLogService.save(log);
+                    throw new RuntimeException("当前任务为空");
                 }
-            }
+                //        //获取配置序数据
+                //任务初始化判断
+                if ("1".equals(tTask.getStatus())) {
+                    //下发的数据才更新状态
+                    tTask.setStatus("2").setStartTime(new Date());
+                    taskMapper.updateById(tTask);
+                    planMapper.updateproduceStatusBegin();
+                    orderMapper.updateproduceStatusBegin();
+
+                    msgUtil.redis_set(CacheKey.PRESOURCE_CURRENT_TASK + "_" + tTask.getResourceId(), tTask.getId());
+                    msgUtil.redis_set(CacheKey.PRESOURCE_CURRENT_TASK_OBJECT + "_" + tTask.getResourceId(), tTask);
+                }
+                //获取配置节点
+                //        String autoProgramUrl = getInterfaceUrl(taskNode);
 
-            tTask = taskMapper.selectById(taskNode.getTaskId());
-            //初始化业务日志
-            log = getBusinessLog(tTask, taskNode);
-
-            try {
-                lockFlag = lock.tryLock();
-                lockCondition = checkFlowCondition(tTask);
-                if(lockFlag){
-                    logger.info("节点{}获取到了执行锁",taskNode.getId());
-                    TaskNode hisTask = taskNodeMapper.selectById(taskNodeId);
-                    if("3".equals(hisTask.getExeResult())){
-                        logger.warn("节点{}已经执行完成，重复推送丢弃",taskNodeId);
-                        log.setExeStatus("3").setExeResult("0").setExeResult("0").setManual("0").setFeedback("节点已经执行完成，重复推送丢弃");
-                        return;
-                    }
+                //填充配置节点内容
+                ResourceAutoCode resourceAutoCode = resourceAutoCodeService.getById(taskNode.getAutoNode().getId());
+                taskNode.setAutoNode(resourceAutoCode);
 
-                    String handMode = jsonObject.getString("handMode");
-                    //多产品搬运类型
-                    String carryType = jsonObject.getString("carryType");
-
-                    String queueName = "device.queue."+ BizConstant.MQ_GLOBAL_EXCEPTION;
-
-                    if (consumerQueue.equals(queueName)) {
-                        StringBuilder buffer = new StringBuilder();
-                        //处理产线存储
-                        String lineName = jsonObject.getString("Line");
-                        ZZone line = zoneService.getOne(new LbqWrapper<ZZone>().like(ZZone::getAbbreviate, lineName.substring(0, lineName.length()-1)));
-                        buffer.append(lineName).append("-设备(").append(jsonObject.getString("Name")+")").append(jsonObject.getString("Status"));
-                        log.setExeResult("0").setManual("1").setFeedback("全局异常:"+ buffer.toString()).setStartTime(new Date()).setExecuteTime(new Date()).setZoneId(line.getId());
-
-                        LbqWrapper<AAutoNodeLog> lbqWrapper = new LbqWrapper<AAutoNodeLog>();
-                        lbqWrapper.eq(AAutoNodeLog::getZoneId, line.getId()).eq(AAutoNodeLog::getExeResult, log.getExeResult()).eq(AAutoNodeLog::getManual, log.getManual()).eq(AAutoNodeLog::getStatus, 0).eq(AAutoNodeLog::getFeedback, log.getFeedback());
-                        //判断全局异常是否已存在
-                        AAutoNodeLog exist = autoNodeLogService.getOne(lbqWrapper);
-                        if(null == exist){
-                            autoNodeLogService.save(log);
-                        }else{
-                            //更新执行时间
-                            exist.setExecuteTime(new Date());
-                            autoNodeLogService.updateAllById(exist);
-                        }
-                        //throw new RuntimeException("全局通知异常");
-                        return;
-                    }
-                    logger.info("=======================" + taskNodeId);
+                isFinal = resourceAutoCode.isFinal() ? true : false;
+                msgUtil.redis_set(CacheKey.TASK_CURRENT_NODE + "_" + taskNode.getResourceId(), resourceAutoCode);
 
-                    //
-                    if (taskNode == null || taskNode.getTaskId() == null) {
-                        //模拟处理数据
-                        log.setExeResult("0").setManual("0").setFeedback("当前任务节点为空");
-                        autoNodeLogService.save(log);
-                        throw new RuntimeException("当前任务节点为空");
-                    }
+                //更新节点任务
+                if("1".equals(taskNode.getExeStatus())){
+                    taskNode.setExeStatus("2").setStartTime(new Date());
+                    taskNodeMapper.updateAllById(taskNode);
+                }
 
-                    if (tTask == null || tTask.getStatus() == "3") {
-                        log.setTaskNodeId(taskNode.getId()).setExeResult("0").setManual("0").setFeedback("当前任务为空");
-                        autoNodeLogService.save(log);
-                        throw new RuntimeException("当前任务为空");
+                if ("04".equals(taskNode.getInterfaceType())&&!"3".equals(bizType)) {
+                    //人工上下料或质检
+                    //不用调接口，直接返回成功
+                    conMap.put("result",true);
+                    msgUtil.redis_set(CacheKey.TASK_CURRENT_NODE_STATUS + "_" + taskNode.getId(), "0");
+                } else {
+                    Map queryMap = Maps.newHashMap();
+                    queryMap.put("bizType", bizType);
+                    if("3".equals(bizType)){
+                        String functionName = jsonObject.getString("functionName");
+                        queryMap.put("functionName",functionName);
                     }
-                    //        //获取配置序数据
-                    //任务初始化判断
-                    if ("1".equals(tTask.getStatus())) {
-                        //下发的数据才更新状态
-                        tTask.setStatus("2").setStartTime(new Date());
-                        taskMapper.updateById(tTask);
-                        planMapper.updateproduceStatusBegin();
-                        orderMapper.updateproduceStatusBegin();
-
-                        msgUtil.redis_set(CacheKey.PRESOURCE_CURRENT_TASK + "_" + tTask.getResourceId(), tTask.getId());
-                        msgUtil.redis_set(CacheKey.PRESOURCE_CURRENT_TASK_OBJECT + "_" + tTask.getResourceId(), tTask);
+                    queryMap.put("carryType", carryType);
+                    queryMap.put("handMode", handMode);
+                    if (jsonObject.containsKey(taskNode.getId() + "count")) {
+                        queryMap.put(taskNode.getId() + "count", jsonObject.getString(taskNode.getId() + "count"));
                     }
-                    //获取配置节点
-                    //        String autoProgramUrl = getInterfaceUrl(taskNode);
 
-                    //填充配置节点内容
-                    ResourceAutoCode resourceAutoCode = resourceAutoCodeService.getById(taskNode.getAutoNode().getId());
-                    taskNode.setAutoNode(resourceAutoCode);
+                    //把产线放进去，避免多次查询节点业务参数
+                    ZZoneProductionresource zoneProductionresource = zZoneProductionresourceMapper.selectOne(Wraps.<ZZoneProductionresource>lbQ().eq(ZZoneProductionresource::getResourceId, taskNode.getResourceId()));
+                    ZZone zZone = zoneService.getById(zoneProductionresource.getZoneId());
+                    queryMap.put("zone", zZone);
 
-                    isFinal = resourceAutoCode.isFinal() ? true : false;
-                    msgUtil.redis_set(CacheKey.TASK_CURRENT_NODE + "_" + taskNode.getResourceId(), resourceAutoCode);
 
-                    //更新节点任务
-                    if("1".equals(taskNode.getExeStatus())){
-                        taskNode.setExeStatus("2").setStartTime(new Date());
-                        taskNodeMapper.updateAllById(taskNode);
-                    }
-
-                    if ("04".equals(taskNode.getInterfaceType())&&!"3".equals(bizType)) {
-                        //人工上下料或质检
-                        //不用调接口，直接返回成功
-                        conMap.put("result",true);
-                        msgUtil.redis_set(CacheKey.TASK_CURRENT_NODE_STATUS + "_" + taskNode.getId(), "0");
-                    } else {
-                        Map queryMap = Maps.newHashMap();
-                        queryMap.put("bizType", bizType);
-                        if("3".equals(bizType)){
-                            String functionName = jsonObject.getString("functionName");
-                            queryMap.put("functionName",functionName);
-                        }
-                        queryMap.put("carryType", carryType);
-                        queryMap.put("handMode", handMode);
-                        if (jsonObject.containsKey(taskNode.getId() + "count")) {
-                            queryMap.put(taskNode.getId() + "count", jsonObject.getString(taskNode.getId() + "count"));
-                        }
+                    BBom bom = bBomMapper.selectById(tTask.getBomId());
+                    ZZone bomzZone = zoneService.getById(bom.getId());
+                    queryMap.put("bomzZone", bomzZone);
 
-                        //把产线放进去，避免多次查询节点业务参数
-                        ZZoneProductionresource zoneProductionresource = zZoneProductionresourceMapper.selectOne(Wraps.<ZZoneProductionresource>lbQ().eq(ZZoneProductionresource::getResourceId, taskNode.getResourceId()));
-                        ZZone zZone = zoneService.getById(zoneProductionresource.getZoneId());
-                        queryMap.put("zone", zZone);
+                    //设置workpiece表当前执行的工序
+                    List<TWorkpiece>list = workpieceMapper.selectList(Wraps.<TWorkpiece>lbQ().eq(TWorkpiece::getCompleteBatchNo,taskNode.getCompleteBatchNo()));
+                    if(CollectionUtil.isNotEmpty(list)){
+                        TWorkpiece workpiece = list.get(0);
+                        workpiece.setProcedureId(tTask.getProcedureId());
+                        workpiece.setTaskNodeId(Long.parseLong(taskNodeId));
+                        workpieceMapper.updateById(workpiece);
+                    }
 
 
-                        BBom bom = bBomMapper.selectById(tTask.getBomId());
-                        ZZone bomzZone = zoneService.getById(bom.getId());
-                        queryMap.put("bomzZone", bomzZone);
 
-                        //设置workpiece表当前执行的工序
-                        List<TWorkpiece>list = workpieceMapper.selectList(Wraps.<TWorkpiece>lbQ().eq(TWorkpiece::getCompleteBatchNo,taskNode.getCompleteBatchNo()));
-                        if(CollectionUtil.isNotEmpty(list)){
-                            TWorkpiece workpiece = list.get(0);
-                            workpiece.setProcedureId(tTask.getProcedureId());
-                            workpiece.setTaskNodeId(Long.parseLong(taskNodeId));
-                            workpieceMapper.updateById(workpiece);
-                        }
+                    //运行条件验证
+                    conMap = checkCon(taskNode, tTask, queryMap);
+                    //conMap.put("result", true);
+                    logger.warn("节点{}检查资源返回{}",taskNode.getId(), conMap);
+                    msgUtil.redis_set_map(CacheKey.TASK_CURRENT_NODE_CONDITION + "_" + taskNode.getId(), conMap);
 
+                    if((boolean)conMap.get("result")){
+                        if ("03".equals(taskNode.getInterfaceType())) {
+                            // 执行线边库操作
+                            if("1".equals(conMap.get("targetxbk"))){
+                                //组装接口参数
+                                HttpHeaders headers = new HttpHeaders();
+                                headers.setContentType(MediaType.parseMediaType("application/json;charset=UTF-8"));
+                                String jsonParam = getRequestParam(conMap);
+                                //缓存执行当前节点传参
+                                msgUtil.redis_set(CacheKey.TASK_CURRENT_NODE_PARAMS + "_" + taskNode.getId(), jsonParam);
+                                HttpEntity<String> formEntity = new HttpEntity<String>(jsonParam, headers);
 
+                                //动态调用接口和新增指令执行时间
+                                log.setZoneId(zZone.getId()).setMethod(conMap.get("method").toString()).setExecuteTime(new Date());
+                                String instructionUrl = conMap.get("instructionUrl") + "/api/" + conMap.get("method").toString();
+                                logger.info("instructionUrl=" + instructionUrl);
+                                logger.info("jsonParam=" + jsonParam);
+                                returnData = restTemplate.postForObject(instructionUrl, formEntity, String.class);
 
-                        //运行条件验证
-                        conMap = checkCon(taskNode, tTask, queryMap);
-                        //conMap.put("result", true);
-                        logger.warn("节点{}检查资源返回{}",taskNode.getId(), conMap);
-                        msgUtil.redis_set_map(CacheKey.TASK_CURRENT_NODE_CONDITION + "_" + taskNode.getId(), conMap);
-
-                        if((boolean)conMap.get("result")){
-                            if ("03".equals(taskNode.getInterfaceType())) {
-                                // 执行线边库操作
-                                if("1".equals(conMap.get("targetxbk"))){
-                                    //组装接口参数
-                                    HttpHeaders headers = new HttpHeaders();
-                                    headers.setContentType(MediaType.parseMediaType("application/json;charset=UTF-8"));
-                                    String jsonParam = getRequestParam(conMap);
-                                    //缓存执行当前节点传参
-                                    msgUtil.redis_set(CacheKey.TASK_CURRENT_NODE_PARAMS + "_" + taskNode.getId(), jsonParam);
-                                    HttpEntity<String> formEntity = new HttpEntity<String>(jsonParam, headers);
-
-                                    //动态调用接口和新增指令执行时间
-                                    log.setZoneId(zZone.getId()).setMethod(conMap.get("method").toString()).setExecuteTime(new Date());
-                                    String instructionUrl = conMap.get("instructionUrl") + "/api/" + conMap.get("method").toString();
-                                    logger.info("instructionUrl=" + instructionUrl);
-                                    logger.info("jsonParam=" + jsonParam);
-                                    returnData = restTemplate.postForObject(instructionUrl, formEntity, String.class);
-
-                                    logger.info("returnData=", returnData);
+                                logger.info("returnData=", returnData);
+                            }else{
+                                TaskNode beforTaskNode = taskNodeService.getNextNTaskNode(taskNode, -1);
+                                // agv搬运
+                                Map agvData = new HashMap();
+                                agvData.put("start", conMap.get("start"));
+                                agvData.put("goal", conMap.get("goal"));
+                                agvData.put("taskId", tTask.getId().toString());
+                                agvData.put("taskNodeId", taskNode.getId().toString());
+                                agvData.put("agvTaskType", "0");
+                                String jsonParam = getRequestParam(conMap);
+                                JSONObject agvParam = new JSONObject();
+                                agvParam.putAll(agvData);
+                                //缓存执行当前节点传参
+                                msgUtil.redis_set(CacheKey.TASK_CURRENT_NODE_PARAMS + "_" + taskNode.getId(), agvParam.toJSONString());
+                                String zoneType = (null == msgUtil.redis_get(ParameterKey.PARAMETERS)? "": ((Map<String,String>)msgUtil.redis_get(ParameterKey.PARAMETERS)).get(ParameterKey.ZONE_TYPE).toString());
+                                if(zoneType.equals(ParameterKey.ZONE_SFX)){
+                                    agvData.put("transferType","agv");
+                                    R addAgvTask = externalApiService.processTransferJob(agvData);
                                 }else{
-                                    TaskNode beforTaskNode = taskNodeService.getNextNTaskNode(taskNode, -1);
-                                    // agv搬运
-                                    Map agvData = new HashMap();
-                                    agvData.put("start", conMap.get("start"));
-                                    agvData.put("goal", conMap.get("goal"));
-                                    agvData.put("taskId", tTask.getId().toString());
-                                    agvData.put("taskNodeId", taskNode.getId().toString());
-                                    agvData.put("agvTaskType", "0");
-                                    String jsonParam = getRequestParam(conMap);
-                                    JSONObject agvParam = new JSONObject();
-                                    agvParam.putAll(agvData);
-                                    //缓存执行当前节点传参
-                                    msgUtil.redis_set(CacheKey.TASK_CURRENT_NODE_PARAMS + "_" + taskNode.getId(), agvParam.toJSONString());
-                                    String zoneType = (null == msgUtil.redis_get(ParameterKey.PARAMETERS)? "": ((Map<String,String>)msgUtil.redis_get(ParameterKey.PARAMETERS)).get(ParameterKey.ZONE_TYPE).toString());
-                                    if(zoneType.equals(ParameterKey.ZONE_SFX)){
-                                        agvData.put("transferType","agv");
-                                        R addAgvTask = externalApiService.processTransferJob(agvData);
-                                    }else{
-                                        R addHikTask = agvHikOrderInfoService.addHikTask(agvData);
-                                    }
+                                    R addHikTask = agvHikOrderInfoService.addHikTask(agvData);
+                                }
+                            }
+                        } else {
+                            if (!"04".equals(taskNode.getInterfaceType())||"3".equals(bizType)) {
+                                // 判断当前工序是三坐标或者前一工序是三坐标，分别将三坐标的放和三坐标下一工序的取不调用ccs接口
+                                String method = conMap.get("method")==null?null:conMap.get("method").toString();
+                                ResourceBusiness resourceBusiness = resourceBusinessService.getById(tTask.getResourceBusinessId());
+                                TaskNode beforTaskNode = null;
+                                TTask beforTask = null;
+                                ResourceBusiness beforResourceBusiness = null;
+                                if(taskNode.getCompleteBatchSort() != 1){
+                                    beforTaskNode = taskNodeService.getNextNTaskNode(taskNode,-1);
+                                    beforTask = taskMapper.selectById(beforTaskNode.getTaskId());
+                                    beforResourceBusiness = resourceBusinessService.getById(beforTask.getResourceBusinessId());
                                 }
-                            } else {
-                                if (!"04".equals(taskNode.getInterfaceType())||"3".equals(bizType)) {
-                                    // 判断当前工序是三坐标或者前一工序是三坐标，分别将三坐标的放和三坐标下一工序的取不调用ccs接口
-                                    String method = conMap.get("method")==null?null:conMap.get("method").toString();
-                                    ResourceBusiness resourceBusiness = resourceBusinessService.getById(tTask.getResourceBusinessId());
-                                    TaskNode beforTaskNode = null;
-                                    TTask beforTask = null;
-                                    ResourceBusiness beforResourceBusiness = null;
-                                    if(taskNode.getCompleteBatchSort() != 1){
-                                        beforTaskNode = taskNodeService.getNextNTaskNode(taskNode,-1);
-                                        beforTask = taskMapper.selectById(beforTaskNode.getTaskId());
-                                        beforResourceBusiness = resourceBusinessService.getById(beforTask.getResourceBusinessId());
-                                    }
 
-                                    // begin add by yejian on 20220819 for 将机器人上的缓存位利用历来：如果缓存位数量n-1 >= 1,则可以将工件不放到线边库，直接放在缓存位上暂存后轮训线边库逻辑
-
-                                    logger.info("节点{}执行缓存位线边库逻辑无需再次取放标志{}",taskNode.getId(),conMap.get(YunjianConstant.YUNJIAN_HCW_XBKFLAG));
-                                    if(conMap.containsKey(YunjianConstant.YUNJIAN_HCW_XBKFLAG)){
-                                        // 将消息重新推入消息对列执行缓存为线边库逻辑,直接移动到设备位子从机器人缓存位拿
-                                        logger.info("节点{}执行缓存位线边库逻辑无需再次取放",taskNode.getId());
-                                        List<Storge> storgeList = storgeService.list(Wraps.<Storge>lbQ().eq(Storge::getCampId, taskNode.getId()));
-                                        List<String> storgePoints = storgeList.stream().map(p -> p.getPointId()).collect(Collectors.toList());
-                                        if (CollectionUtil.isNotEmpty(storgeList)) {
-                                            logger.info("节点{}开始释放占用的资源{}", taskNode.getId(),storgePoints.toString());
-                                            storgeService.unlockStorgeList(storgeList);
-                                        }
-                                        msgUtil.pushToNextMq(taskNode,3);
+                                // begin add by yejian on 20220819 for 将机器人上的缓存位利用历来：如果缓存位数量n-1 >= 1,则可以将工件不放到线边库，直接放在缓存位上暂存后轮训线边库逻辑
+
+                                logger.info("节点{}执行缓存位线边库逻辑无需再次取放标志{}",taskNode.getId(),conMap.get(YunjianConstant.YUNJIAN_HCW_XBKFLAG));
+                                if(conMap.containsKey(YunjianConstant.YUNJIAN_HCW_XBKFLAG)){
+                                    // 将消息重新推入消息对列执行缓存为线边库逻辑,直接移动到设备位子从机器人缓存位拿
+                                    logger.info("节点{}执行缓存位线边库逻辑无需再次取放",taskNode.getId());
+                                    List<Storge> storgeList = storgeService.list(Wraps.<Storge>lbQ().eq(Storge::getCampId, taskNode.getId()));
+                                    List<String> storgePoints = storgeList.stream().map(p -> p.getPointId()).collect(Collectors.toList());
+                                    if (CollectionUtil.isNotEmpty(storgeList)) {
+                                        logger.info("节点{}开始释放占用的资源{}", taskNode.getId(),storgePoints.toString());
+                                        storgeService.unlockStorgeList(storgeList);
+                                    }
+                                    msgUtil.pushToNextMq(taskNode,3);
+                                }else{
+                                    String jsonObjectE = conMap.containsKey("data") ? conMap.get("data").toString() : "";
+                                    if("打标业务".equals(resourceBusiness.getName()) && "SendServoStacker".equals(method)){
+                                        // 打标业务无需放
+                                        specialCallBackMyselfFlag = true;
+                                        String jsonParam = getRequestParam(conMap);
+                                        //缓存执行当前节点传参
+                                        msgUtil.redis_set(CacheKey.TASK_CURRENT_NODE_PARAMS + "_" + taskNode.getId(), jsonParam);
+                                        JSONObject ret = new JSONObject();
+                                        ret.put("result","true");
+                                        returnData = ret.toJSONString();
+                                    }else if(taskNode.getCompleteBatchSort()!=1 && "3".equals(beforTask.getStatus()) && resourceBusiness.getName().contains("下料业务") && "GetServoStacker".equals(method) && "打标业务".equals(beforResourceBusiness.getName())){
+                                        specialCallBackMyselfFlag = true;
+                                        String jsonParam = getRequestParam(conMap);
+                                        //缓存执行当前节点传参
+                                        msgUtil.redis_set(CacheKey.TASK_CURRENT_NODE_PARAMS + "_" + taskNode.getId(), jsonParam);
+                                        JSONObject ret = new JSONObject();
+                                        ret.put("result","true");
+                                        returnData = ret.toJSONString();
                                     }else{
-                                        String jsonObjectE = conMap.containsKey("data") ? conMap.get("data").toString() : "";
-                                        if("打标业务".equals(resourceBusiness.getName()) && "SendServoStacker".equals(method)){
-                                            // 打标业务无需放
-                                            specialCallBackMyselfFlag = true;
-                                            String jsonParam = getRequestParam(conMap);
-                                            //缓存执行当前节点传参
-                                            msgUtil.redis_set(CacheKey.TASK_CURRENT_NODE_PARAMS + "_" + taskNode.getId(), jsonParam);
-                                            JSONObject ret = new JSONObject();
-                                            ret.put("result","true");
-                                            returnData = ret.toJSONString();
-                                        }else if(taskNode.getCompleteBatchSort()!=1 && "3".equals(beforTask.getStatus()) && resourceBusiness.getName().contains("下料业务") && "GetServoStacker".equals(method) && "打标业务".equals(beforResourceBusiness.getName())){
-                                            specialCallBackMyselfFlag = true;
-                                            String jsonParam = getRequestParam(conMap);
-                                            //缓存执行当前节点传参
-                                            msgUtil.redis_set(CacheKey.TASK_CURRENT_NODE_PARAMS + "_" + taskNode.getId(), jsonParam);
-                                            JSONObject ret = new JSONObject();
-                                            ret.put("result","true");
-                                            returnData = ret.toJSONString();
-                                        }else{
-                                            try {
-                                                Thread.sleep(1000);
-                                            } catch (InterruptedException e) {
-                                                e.printStackTrace();
-                                            }
-                                            //组装接口参数
-                                            HttpHeaders headers = new HttpHeaders();
-                                            headers.setContentType(MediaType.parseMediaType("application/json;charset=UTF-8"));
-                                            String jsonParam = getRequestParam(conMap);
-                                            //缓存执行当前节点传参
-                                            msgUtil.redis_set(CacheKey.TASK_CURRENT_NODE_PARAMS + "_" + taskNode.getId(), jsonParam);
-
-                                            //动态调用接口和新增指令执行时间
-                                            log.setZoneId(zZone.getId()).setMethod(method).setExecuteTime(new Date());
-                                            String instructionUrl = conMap.get("instructionUrl") + "/api/" + conMap.get("method").toString();
-                                            //String instructionUrl = "127.0.0.1" + "/api/" + conMap.get("method").toString();
-                                            logger.info("instructionUrl={}" ,instructionUrl);
-                                            logger.info("[ECS指令发送]节点传参={}" ,jsonParam);
-
-                                            Date endTime = new Date(); //记录结束时间
-
-                                            logger.warn("任务下发总用时：{}秒", DateUtil.between(startTime,endTime, DateUnit.SECOND));
-
-                                            //起点、终点缓存。
-                                            Storge fstorge = conMap.get("fromStorge") == null ? null : (Storge) conMap.get("fromStorge");
-                                            Storge tstorge = conMap.get("toStorge") == null ? null : (Storge) conMap.get("toStorge");
-                                            if(fstorge !=null || tstorge !=null){
-                                                log.setStartStorge(fstorge.getName());
-                                                log.setEndStorge(tstorge.getName());
-                                            }
-                                            log.setRequestParam(jsonParam);
-                                            log.setRequestUrl(instructionUrl);
-                                            HttpEntity<String> formEntity = new HttpEntity<String>(jsonParam, headers);
-                                            returnData = restTemplate.postForObject(instructionUrl, formEntity, String.class);
-                                            //returnData = "{\"result\": \"true\"}";
+                                        try {
+                                            Thread.sleep(1000);
+                                        } catch (InterruptedException e) {
+                                            e.printStackTrace();
+                                        }
+                                        //组装接口参数
+                                        HttpHeaders headers = new HttpHeaders();
+                                        headers.setContentType(MediaType.parseMediaType("application/json;charset=UTF-8"));
+                                        String jsonParam = getRequestParam(conMap);
+                                        //缓存执行当前节点传参
+                                        msgUtil.redis_set(CacheKey.TASK_CURRENT_NODE_PARAMS + "_" + taskNode.getId(), jsonParam);
+
+                                        //动态调用接口和新增指令执行时间
+                                        log.setZoneId(zZone.getId()).setMethod(method).setExecuteTime(new Date());
+                                        String instructionUrl = conMap.get("instructionUrl") + "/api/" + conMap.get("method").toString();
+                                        //String instructionUrl = "127.0.0.1" + "/api/" + conMap.get("method").toString();
+                                        logger.info("instructionUrl={}" ,instructionUrl);
+                                        logger.info("[ECS指令发送]节点传参={}" ,jsonParam);
+
+                                        Date endTime = new Date(); //记录结束时间
+
+                                        logger.warn("任务下发总用时：{}秒", DateUtil.between(startTime,endTime, DateUnit.SECOND));
+
+                                        //起点、终点缓存。
+                                        Storge fstorge = conMap.get("fromStorge") == null ? null : (Storge) conMap.get("fromStorge");
+                                        Storge tstorge = conMap.get("toStorge") == null ? null : (Storge) conMap.get("toStorge");
+                                        if(fstorge !=null || tstorge !=null){
+                                            log.setStartStorge(fstorge.getName());
+                                            log.setEndStorge(tstorge.getName());
+                                        }
+                                        log.setRequestParam(jsonParam);
+                                        log.setRequestUrl(instructionUrl);
+                                        HttpEntity<String> formEntity = new HttpEntity<String>(jsonParam, headers);
+                                        //returnData = restTemplate.postForObject(instructionUrl, formEntity, String.class);
+                                        returnData = "{\"result\": \"true\"}";
 
 
-                                        }
                                     }
                                 }
                             }
                         }
                     }
-                }else{
-                    logger.warn("节点{}未获取到了执行锁",taskNode.getId());
-                    log.setManual("0").setFeedback("节点"+taskNode.getId()+"未获取到了执行锁");
-                    conMap.put("result",false);
                 }
-            } catch (BizException e) {
-                e.printStackTrace();
-                conMap.put("result",false);
-                JSONObject errJsonObject = new JSONObject();
-                errJsonObject.put("code", "exception");
-                errJsonObject.put("msg", e.getMessage());
-                errJsonObject.put("result","false");
-                returnData = errJsonObject.toJSONString();
-                logger.warn("调用接口发生异常" + e.getMessage());
-                log.setManual("0").setFeedback("调用接口发生异常" + e.getMessage());
-            } catch (Exception e) {
+            }else{
+                logger.warn("节点{}未获取到了执行锁",taskNode.getId());
+                log.setManual("0").setFeedback("节点"+taskNode.getId()+"未获取到了执行锁");
                 conMap.put("result",false);
-
-                // 释放占用资源并在autolog表中增加日志，方便指令重发
-                JSONObject errJsonObject = new JSONObject();
-                errJsonObject.put("code", "exception");
-                errJsonObject.put("msg", e.getMessage());
-                errJsonObject.put("result","false");
-                returnData = errJsonObject.toJSONString();
-
-                e.printStackTrace();
-                logger.warn("节点{},逻辑出现异常:{}" ,taskNode.getId(), e.getStackTrace());
-                log.setManual("0").setFeedback("节点"+taskNode.getId()+"逻辑出现异常");
-                //插入执行日志
-                autoNodeLogMapper.updateAllById(log);
-            } finally {
-                logger.warn("returnData={}",returnData);
-                JSONObject retJson = JSONObject.parseObject(returnData);
-                if (retJson != null) {
-                    String code = retJson.getString("result").trim();
-                    String concurrency = retJson.containsKey("concurrency")? retJson.getString("concurrency").trim() : "false";
-                    if (code.equals("true")) {
-                        //回调处理
-                        log.setExeStatus("3").setEndTime(new Date()).setSendStatus("1");
-                    } else if (code.equals("false")) {
-                        //需要人工处理解决警报异常
-                        log.setManual("1").setFeedback(retJson.getString("msg"));
-                        // 释放之前占用的资源 并发延迟带来的异常不释放锁定资源
-                        if(concurrency.equals("false")) {
-                            // begin modify by yejian on 20220520 for 解决资源抢占时机器人是空闲状态但是实际上面有料不能操作的时候请求指令接口返回失败后进入死循环问题
-                            taskNodeService.freeLock(taskNode.getCompleteBatchNo());
-                            logger.warn("{}设备资源不通过释放节点", taskNode.getCompleteBatchNo());
-                        }
-                        conMap.put("result", false);
-                    } else if (code.equals("exception")) {
-                        //执行异常处理（无须人工处理和警报提示)
-                        log.setManual("0").setFeedback(retJson.getString("msg"));
-                    }
-                }else{
-                    // 非人工序
-                    logger.info("节点{}名称{}类型{}",taskNode.getId(),taskNode.getNodeName(),taskNode.getInterfaceType());
-                    if (!"04".equals(taskNode.getInterfaceType())) {
-                        if((boolean)conMap.get("result")){
-                            log.setManual("0").setFeedback("节点"+taskNode.getId()+"操作响应超时");
-                        }else{
-                            //设备不在线默认存储为空
-                            log.setManual("0").setFeedback(null);
-                        }
+            }
+        } catch (BizException e) {
+            e.printStackTrace();
+            conMap.put("result",false);
+            JSONObject errJsonObject = new JSONObject();
+            errJsonObject.put("code", "exception");
+            errJsonObject.put("msg", e.getMessage());
+            errJsonObject.put("result","false");
+            returnData = errJsonObject.toJSONString();
+            logger.warn("调用接口发生异常" + e.getMessage());
+            log.setManual("0").setFeedback("调用接口发生异常" + e.getMessage());
+        } catch (Exception e) {
+            conMap.put("result",false);
+
+            // 释放占用资源并在autolog表中增加日志，方便指令重发
+            JSONObject errJsonObject = new JSONObject();
+            errJsonObject.put("code", "exception");
+            errJsonObject.put("msg", e.getMessage());
+            errJsonObject.put("result","false");
+            returnData = errJsonObject.toJSONString();
+
+            e.printStackTrace();
+            logger.warn("节点{},逻辑出现异常:{}" ,taskNode.getId(), e.getStackTrace());
+            log.setManual("0").setFeedback("节点"+taskNode.getId()+"逻辑出现异常");
+            //插入执行日志
+            autoNodeLogMapper.updateAllById(log);
+        } finally {
+            logger.warn("returnData={}",returnData);
+            JSONObject retJson = JSONObject.parseObject(returnData);
+            if (retJson != null) {
+                String code = retJson.getString("result").trim();
+                String concurrency = retJson.containsKey("concurrency")? retJson.getString("concurrency").trim() : "false";
+                if (code.equals("true")) {
+                    //回调处理
+                    log.setExeStatus("3").setEndTime(new Date()).setSendStatus("1");
+                } else if (code.equals("false")) {
+                    //需要人工处理解决警报异常
+                    log.setManual("1").setFeedback(retJson.getString("msg"));
+                    // 释放之前占用的资源 并发延迟带来的异常不释放锁定资源
+                    if(concurrency.equals("false")) {
+                        // begin modify by yejian on 20220520 for 解决资源抢占时机器人是空闲状态但是实际上面有料不能操作的时候请求指令接口返回失败后进入死循环问题
+                        taskNodeService.freeLock(taskNode.getCompleteBatchNo());
+                        logger.warn("{}设备资源不通过释放节点", taskNode.getCompleteBatchNo());
                     }
+                    conMap.put("result", false);
+                } else if (code.equals("exception")) {
+                    //执行异常处理（无须人工处理和警报提示)
+                    log.setManual("0").setFeedback(retJson.getString("msg"));
                 }
-                if (log.getId() == null) {
-                    autoNodeLogService.save(log);
-                } else {
-                    log.setExecuteTime(new Date());
-                    autoNodeLogService.updateAllById(log);
-                }
-                logger.info("specialCallBackMyselfFlag={}",specialCallBackMyselfFlag);
-                if(specialCallBackMyselfFlag){
-                    // 打标机或恒轮上传程序特殊处理
-                    JSONObject callBackData = new JSONObject();
-                    callBackData.put("code","1");
-                    callBackData.put("msg","操作成功");
-                    callBackData.put("taskId",taskNode.getTaskId());
-                    callBackData.put("taskNodeId",taskNode.getId());
-                    String taskNodeCallbackUrl = (null == msgUtil.redis_get(ParameterKey.PARAMETERS)? "": ((Map<String,String>)msgUtil.redis_get(ParameterKey.PARAMETERS)).get(ParameterKey.TASKNODECALLBACKURL).toString());
-                    //组装接口参数
-                    HttpHeaders headers = new HttpHeaders();
-                    headers.setContentType(MediaType.parseMediaType("application/json;charset=UTF-8"));
-                    HttpEntity<String> formEntity = new HttpEntity<String>(callBackData.toJSONString(), headers);
-                    restTemplate.postForObject(taskNodeCallbackUrl, formEntity, String.class);
-                }
-                if(lockFlag){
-                    lock.unlock();
-                    logger.info("节点{}名称{}释放锁",taskNode.getId(),taskNode.getNodeName());
-                }
-                if(!(boolean)conMap.get("result")){
-                    throw new InterruptedException("设备资源不通过，消息重新进入队尾");
+            }else{
+                // 非人工序
+                logger.info("节点{}名称{}类型{}",taskNode.getId(),taskNode.getNodeName(),taskNode.getInterfaceType());
+                if (!"04".equals(taskNode.getInterfaceType())) {
+                    if((boolean)conMap.get("result")){
+                        log.setManual("0").setFeedback("节点"+taskNode.getId()+"操作响应超时");
+                    }else{
+                        //设备不在线默认存储为空
+                        log.setManual("0").setFeedback(null);
+                    }
                 }
             }
+            if (log.getId() == null) {
+                autoNodeLogService.save(log);
+            } else {
+                log.setExecuteTime(new Date());
+                autoNodeLogService.updateAllById(log);
+            }
+            logger.info("specialCallBackMyselfFlag={}",specialCallBackMyselfFlag);
+            if(specialCallBackMyselfFlag){
+                // 打标机或恒轮上传程序特殊处理
+                JSONObject callBackData = new JSONObject();
+                callBackData.put("code","1");
+                callBackData.put("msg","操作成功");
+                callBackData.put("taskId",taskNode.getTaskId());
+                callBackData.put("taskNodeId",taskNode.getId());
+                String taskNodeCallbackUrl = (null == msgUtil.redis_get(ParameterKey.PARAMETERS)? "": ((Map<String,String>)msgUtil.redis_get(ParameterKey.PARAMETERS)).get(ParameterKey.TASKNODECALLBACKURL).toString());
+                //组装接口参数
+                HttpHeaders headers = new HttpHeaders();
+                headers.setContentType(MediaType.parseMediaType("application/json;charset=UTF-8"));
+                HttpEntity<String> formEntity = new HttpEntity<String>(callBackData.toJSONString(), headers);
+                restTemplate.postForObject(taskNodeCallbackUrl, formEntity, String.class);
+            }
+            if(lockFlag){
+                lock.unlock();
+                logger.info("节点{}名称{}释放锁",taskNode.getId(),taskNode.getNodeName());
+            }
+            if(!(boolean)conMap.get("result")){
+                throw new InterruptedException("设备资源不通过，消息重新进入队尾");
+            }
         }
+
     }
 
     public boolean checkRobotHand(String handType){
@@ -1139,8 +1082,8 @@ public class TaskWorkNode {
                         locationMap.put("destLocation",targetStorge.getPointId()); //机器人缓存位
                         locationMap.put("taskType",DictionaryKey.TASK_TYPE.get("CARRY"));
                         locationMap.put("mode","256");
-                        String trayCategoryType = this.getTrayCategoryType(taskNode.getId());
-                        locationMap.put("carryType",trayCategoryType);
+                        //String trayCategoryType = this.getTrayCategoryType(taskNode.getId());
+                        locationMap.put("carryType","1");
 
                         dataMap.put("data", locationMap);
                         dataMap.put("method", "RobotAction");
@@ -1674,7 +1617,7 @@ public class TaskWorkNode {
                 return CollectionUtil.isNotEmpty(robotList) && jqrMap.containsKey(DemoLineConstant.DEMOLINE_RJQR_ZS);
             }else{
                 Map<String, List<ProductionresourcePosition>> jqrMap = robotList.stream().collect(groupingBy(ProductionresourcePosition::getPointId));
-                return CollectionUtil.isNotEmpty(robotList) && robotList.size() > 1 && jqrMap.containsKey(DemoLineConstant.DEMOLINE_RJQR_ZS);
+                return CollectionUtil.isNotEmpty(robotList);
             }
         }
         return true;

imcs-admin-boot/imcs-business-biz/src/main/java/com/github/zuihou/business/operationManagementCenter/service/impl/TaskNodeServiceImpl.java

@@ -1575,7 +1575,7 @@ public class TaskNodeServiceImpl extends SuperServiceImpl<TaskNodeMapper, TaskNo
         JSONObject callBackJsonParam = JSONObject.parseObject(jsonParam);
 
         String taskType = callBackJsonParam.get("taskType").toString();
-        String carryType = callBackJsonParam.get("carryType").toString();
+        String carryType = callBackJsonParam.get("carryType") !=null ? callBackJsonParam.get("carryType").toString() : "";
         if(DictionaryKey.CARRY_TYPE.get("TOOL").equals(carryType)){
             //刀具任务
             return toolTaskNodeService.toolTaskNodeCallback(bean);

imcs-admin-boot/imcs-business-biz/src/main/java/com/github/zuihou/business/productionReadyCenter/service/impl/TrayServiceImpl.java

@@ -12,6 +12,7 @@ import com.github.zuihou.business.productionReadyCenter.service.MToolClampServic
 import com.github.zuihou.business.productionReadyCenter.service.TrayPositionService;
 import com.github.zuihou.business.productionReadyCenter.service.TrayService;
 import com.github.zuihou.common.constant.CodeRuleModule;
+import com.github.zuihou.common.util.StringUtil;
 import com.github.zuihou.database.mybatis.auth.DataScope;
 import com.github.zuihou.database.mybatis.conditions.Wraps;
 import com.github.zuihou.database.mybatis.conditions.query.LbqWrapper;
@@ -58,6 +59,9 @@ public class TrayServiceImpl extends SuperServiceImpl<TrayMapper, Tray> implemen
     @Transactional(rollbackFor = Exception.class)
     public Tray save(TraySaveDTO data) {
         Tray module = BeanPlusUtil.toBean(data, Tray.class);
+        if(StringUtil.isNotEmpty(module.getName())){
+            module.setName(module.getName() + "_托盘");
+        }
         //根据编码规则
         //String no = codeRuleService.getBillCode(CodeRuleModule.CODE_RULE_TRAY);
         //module.setNo(no);

imcs-admin-boot/imcs-business-biz/src/main/java/com/github/zuihou/business/productionResourceCenter/service/impl/RobotNodeServiceImpl.java

@@ -480,23 +480,6 @@ public class RobotNodeServiceImpl implements NodeOperationService {
                                 jqrStorge = storgeService.getById(jqrMap.get(DemoLineConstant.DEMOLINE_RJQR_ZS).get(0).getStorgeId());
                                 jqrStorge.setCompleteBatchNo(task.getCompleteBatchNo());
                                 storgeService.lockStorge(jqrStorge, taskNode.getId());
-                                /*//锁定一个缓存位
-                                List<ProductionresourcePosition> hcwList = jqrMap.get(jqrMap.keySet().stream().filter(p -> !DemoLineConstant.DEMOLINE_RJQR_ZS.equals(p) && !DemoLineConstant.DEMOLINE_RJQR_SIX.equals(p)).findFirst().get());
-                                Storge hcwStorge = storgeService.getById(hcwList.get(0).getStorgeId());
-                                hcwStorge.setCompleteBatchNo(task.getCompleteBatchNo());
-                                storgeService.lockStorge(hcwStorge, nextTaskNode.getId());
-*/
-                                // add by yejian on 20220819 for 将机器人上的缓存位利用历来：如果缓存位数量n-1 >= 1,则可以将工件不放到线边库，直接放在缓存位上暂存后轮训线边库逻辑
-                                //List<ProductionresourcePosition> robotHcwList = robotList.stream().filter(p -> !p.getPointId().equals(DemoLineConstant.DEMOLINE_RJQR_ZS)).collect(Collectors.toList());
-
-                                //log.info("节点{}检查机器人缓存位库位数{}",taskNode.getId(),robotHcwList.size());
-                                /*nextTaskNode = taskNodeService.getNextNTaskNode(taskNode,1);
-                                if (!"机械手放到立库".equals(nextTaskNode.getNodeName()) && null != nextTaskNode.getTargetResourceId() && !targetStorgeResourceId.equals(nextTaskNode.getTargetResourceId()) && robotHcwList.size() > 1){
-                                    targetStorge = hcwStorge;
-                                    msgUtil.redis_set(DemoCacheKey.YUNJIAN_CAMP + "_" + DemoLineConstant.YUNJIAN_TARGET_HCW_XBK_FLAG + nextTaskNode.getId(), targetxbk, 10, TimeUnit.DAYS);
-                                }else{
-
-                                }*/
 
                                 //锁定起点库位
                                 startStore.setCompleteBatchNo(task.getCompleteBatchNo());
@@ -505,20 +488,12 @@ public class RobotNodeServiceImpl implements NodeOperationService {
                                 //锁定目标库位
                                 targetStorge.setCompleteBatchNo(task.getCompleteBatchNo());
                                 storgeService.lockStorge(targetStorge, taskNode.getId());
-                                // 放入线边库或机器人缓存位
-                               // log.info("节点{}提前占用机器人抓手{},缓存位{},目标库位{}",taskNode.getId(),jqrStorge.getPointId(),hcwStorge.getPointId(),targetStorge.getPointId());
-                                //抓手缓存
-                                //msgUtil.redis_set(DemoCacheKey.YUNJIAN_CAMP + "_" + YunjianConstant.YUNJIAN_JXS + nextTaskNode.getId(), jqrStorge, 10, TimeUnit.DAYS);
                                 msgUtil.redis_set(DemoCacheKey.YUNJIAN_CAMP + "_" + YunjianConstant.YUNJIAN_JXS + taskNode.getId(), jqrStorge, 10, TimeUnit.DAYS);
-                                //缓存位缓存
-                                /*msgUtil.redis_set(DemoCacheKey.YUNJIAN_CAMP + "_" + YunjianConstant.YUNJIAN_HCW + nextTaskNode.getId(), hcwStorge, 10, TimeUnit.DAYS);
-                                msgUtil.redis_set(DemoCacheKey.YUNJIAN_CAMP + "_" + YunjianConstant.YUNJIAN_HCW + taskNode.getId(), hcwStorge, 10, TimeUnit.DAYS);*/
                                 //目标缓存
                                 msgUtil.redis_set(DemoCacheKey.YUNJIAN_CAMP + "_" + DemoLineConstant.YUNJIAN_TARGET_STORE + taskNode.getId(), targetStorge, 10, TimeUnit.DAYS);
 
                                 //目标是线边库
                                 msgUtil.redis_set(DemoCacheKey.YUNJIAN_CAMP + "_" + DemoLineConstant.YUNJIAN_TARGET_XBK_FLAG + taskNode.getId(), targetxbk, 10, TimeUnit.DAYS);
-                                //msgUtil.redis_set(DemoCacheKey.YUNJIAN_CAMP + "_" + DemoLineConstant.YUNJIAN_TARGET_XBK_FLAG + nextTaskNode.getId(), targetxbk, 10, TimeUnit.DAYS);
                                 if(StringUtil.isNotEmpty(targetxbk) && "1".equals(targetxbk)){
                                     //放线边库
                                     dataMap.put(YunjianConstant.YUNJIAN_XBKFLAG, YunjianConstant.YUNJIAN_XBKFLAG);
@@ -540,11 +515,9 @@ public class RobotNodeServiceImpl implements NodeOperationService {
                                 locationMap.put("location",startStore.getPointId());  //零件当前位置
                                 locationMap.put("destLocation",targetStorge.getPointId()); //机器人缓存位
                                 locationMap.put("taskType",DictionaryKey.TASK_TYPE.get("CARRY"));
-                                locationMap.put("newRfid",newRfid);
-                                locationMap.put("oldRfid",tWorkpiece.getUniqueCode());
                                 locationMap.put("mode","256");
-                                String trayCategoryType = this.getTrayCategoryType(taskNode.getId());
-                                locationMap.put("carryType",trayCategoryType);
+                                //String trayCategoryType = this.getTrayCategoryType(taskNode.getId());
+                                locationMap.put("carryType","1");
 
                                 dataMap.put("data", locationMap);
                                 dataMap.put("method", "RobotAction");
@@ -554,10 +527,6 @@ public class RobotNodeServiceImpl implements NodeOperationService {
 
                                 // 机器人移动到redis记录实时位子
                                 msgUtil.redis_set(taskNode.getResourceId()+"postion",targetStorge.getPointId());
-
-                                // 记录机器人移动到对应设备
-                                ProductionresourcePosition productionresourcePosition = productionresourcePositionMapper.selectOne(new QueryWrap<ProductionresourcePosition>().lambda().eq(ProductionresourcePosition::getStorgeId, targetStorge.getId()));
-                                msgUtil.redis_set("JQR_RESOURCE",productionresourcePosition.getResourceId());
                             }else{
                                 log.warn("节点{}目标位置为空", taskNode.getId());
                                 dataMap.put("result", false);
@@ -570,114 +539,6 @@ public class RobotNodeServiceImpl implements NodeOperationService {
                     }
                 }
             }
-        }else if ("取".equals(functionName)) {
-            Storge targetStorge = msgUtil.redis_get(DemoCacheKey.YUNJIAN_CAMP + "_" + DemoLineConstant.YUNJIAN_TARGET_STORE + taskNode.getId())==null?null:(Storge)msgUtil.redis_get(DemoCacheKey.YUNJIAN_CAMP + "_" + DemoLineConstant.YUNJIAN_TARGET_STORE + taskNode.getId());
-            //执行到第几步
-            dataMap.put(taskNode.getId().toString()+"count",count);
-            if(BizConstant.ROBOT_TYPE_CACHE.equals(zoneService.getRobotTypebyZone(zoneName))){
-
-                // begin add by yejian on 20220819 for 将机器人上的缓存位利用历来：如果缓存位数量n-1 >= 1,则可以将工件不放到线边库，直接放在缓存位上暂存后轮训线边库逻辑
-                String targetHcwXbk =(String)msgUtil.redis_get(DemoCacheKey.YUNJIAN_CAMP + "_" + DemoLineConstant.YUNJIAN_TARGET_HCW_XBK_FLAG + taskNode.getId());
-                log.info("节点{}放逻辑判断{}",taskNode.getId(),targetHcwXbk);
-                if("1".equals(targetHcwXbk)){
-                    // 释放锁定机器人资源
-                    List<Storge> storgeList = storgeService.list(Wraps.<Storge>lbQ().eq(Storge::getCampId, taskNode.getId()));
-                    storgeService.unlockStorgeList(storgeList);
-                    log.info("节点{}执行暂存缓存为线边库逻辑",taskNode.getId());
-                    dataMap.put(YunjianConstant.YUNJIAN_XBKFLAG, targetHcwXbk);
-                    dataMap.put(YunjianConstant.YUNJIAN_HCW_XBKFLAG, targetHcwXbk);
-                    dataMap.put("result", true);
-                }else{
-                    dataMap.put(YunjianConstant.YUNJIAN_ROBORT_CACHE_FLAG, "1");
-                    if(count==0) {
-
-                        // begin add by yejian on 20220921 for 机器人缓存位上面有料时先判断当前机器人移动所在位子是否和机器人缓存台上面的暂存物料的目标地址一致，
-                        // 如果一致，先将缓存台物料放到目标地址,实现逻辑通过redis加机器人所在位子和跳过机器人是否可用逻辑，直接让缓存位上面的任务先执行beta
-                        // 查询机器人缓存位上面是否存在物料并且目标地址是否当前机器所在位子
-                        List<ProductionresourcePosition> jrqHcwWorkpieceInfos = productionresourcePositionService.getFullProductionresourcePositionByIds(deviceArr);
-                        List<Long> jrqHcwStorgeIds = jrqHcwWorkpieceInfos.stream().mapToLong(ProductionresourcePosition::getStorgeId).boxed().collect(Collectors.toList());
-                        List<Storge> jrqHcwStorges = jrqHcwStorgeIds.size()==0 ? new ArrayList<Storge>() : storgeMapper.selectList(Wraps.<Storge>lbQ().in(Storge::getId,jrqHcwStorgeIds));
-                        log.info("节点{}当前缓存位数工件信息{}",taskNode.getId(),jrqHcwStorges.toString());
-                        boolean hasJqrhcwPartFlag = false;
-                        String jrqHcwPartPoint =  msgUtil.redis_get(deviceArr[0] + "postion") == null ? "": String.valueOf(msgUtil.redis_get(deviceArr[0] + "postion"));
-                        log.info("节点{}当前机器人所在位子{}",taskNode.getId(),jrqHcwPartPoint);
-
-                        for(Storge jqrHcwStorge : jrqHcwStorges){
-                            Long jqrHcwStorgeTaskNodeId = jqrHcwStorge.getCampId();
-                            if(null==jqrHcwStorgeTaskNodeId) {
-                                jqrHcwStorgeTaskNodeId = workpieceService.getOne(new LbqWrapper<TWorkpiece>().eq(TWorkpiece::getStorgeId, jqrHcwStorge.getId()).eq(TWorkpiece::getIsEnd, "0")).getTaskNodeId();
-                            }
-                            TaskNode jqrHcwStorgeTaskNode = taskNodeService.getById(jqrHcwStorgeTaskNodeId);
-                            //当前节点零件和缓存位上的零件不相同
-                            if(!jqrHcwStorgeTaskNode.getCompleteBatchNo().equals(taskNode.getCompleteBatchNo())){
-                                //缓存位目标设备的点位
-                                if(jqrHcwStorgeTaskNode.getTargetResourceId()==null) continue;
-                                    ProductionresourcePosition jqrHcwStorgeTaskNodeResource = productionresourcePositionMapper.selectOne(Wraps.<ProductionresourcePosition>lbQ().eq(ProductionresourcePosition::getResourceId, jqrHcwStorgeTaskNode.getTargetResourceId()));
-                                    log.info("jqrHcwStorgeTaskNode.getCompleteBatchNo()={}", jqrHcwStorgeTaskNode.getCompleteBatchNo());
-                                    log.info("taskNode.getCompleteBatchNo()={}", taskNode.getCompleteBatchNo());
-
-                                    // 查询缓存位工件目标地址是否是机器人当前位子
-                                    log.info("jqrHcwStorgeTaskNodeResource.getPointId()={}", jqrHcwStorgeTaskNodeResource.getPointId());
-                                    log.info("jrqHcwPartPoint={}", jrqHcwPartPoint);
-                                if(jqrHcwStorgeTaskNodeResource.getPointId().equals(jrqHcwPartPoint)){
-                                    hasJqrhcwPartFlag = true;
-                                    msgUtil.redis_set(DemoLineConstant.JQR_HCW_PART_PRIOTY_EXEC_FLAG + jqrHcwStorgeTaskNodeId,"1");
-                                    break;
-                                }
-                            }
-                        }
-                        log.info("节点{}是否存在当前缓存位上工件先放到目标设备标志{}",taskNode.getId(),hasJqrhcwPartFlag);
-                        if(hasJqrhcwPartFlag){
-                            dataMap.put("result", false);
-                        }else{
-                            String newRfid = getRFID(taskNode.getId(), task.getId(), startStore.getId());
-
-                            //记录当前节点RFID
-                            msgUtil.redis_set(DemoCacheKey.YUNJIAN_CAMP + "_" + YunjianConstant.YUNJIAN_RFID + taskNode.getId(), newRfid, 10, TimeUnit.DAYS);
-
-                            int storageCount = storgeService.count(new LbqWrapper<Storge>().eq(Storge::getCompleteBatchNo, taskNode.getCompleteBatchNo()).eq(Storge::getCampId, taskNode.getId()).eq(Storge::getLockStatus, "0"));
-                            //当前零件满足锁定节点的零件一致允许移动
-                            if(storageCount>0) {
-
-                                TaskNode beforeTaskNode = taskNodeService.getNextNTaskNode(taskNode, -1);
-                                if(beforeTaskNode.getNodeName().indexOf("从立库取") > -1){
-                                    dataMap.put(DemoLineConstant.DEMOLINE_STOCK_TYPE, DemoLineConstant.DEMOLINE_STOCK_TYPE_TRAY_CRK);
-                                }else{
-                                    dataMap.put(DemoLineConstant.DEMOLINE_STOCK_TYPE, DemoLineConstant.DEMOLINE_STOCK_TYPE_ALL_CRK);
-                                }
-
-                                Map locationMap = new HashMap();
-                                locationMap.put("location",startStore.getPointId());  //机器人当前位置
-                                locationMap.put("destLocation", targetStorge.getPointId());
-                                locationMap.put("taskType",DictionaryKey.TASK_TYPE.get("CARRY"));
-                                locationMap.put("newRfid",newRfid);
-                                locationMap.put("oldRfid",tWorkpiece.getUniqueCode());
-                                locationMap.put("mode","256");
-
-                                String trayCategoryType = this.getTrayCategoryType(taskNode.getId());
-                                locationMap.put("carryType",trayCategoryType);
-
-                                dataMap.put("data", locationMap);
-                                dataMap.put("method", "RobotAction");
-                                dataMap.put("result", true);
-                                dataMap.put("fromStorge", startStore);
-                                dataMap.put("toStorge", targetStorge);
-
-                                // 机器人移动到redis记录实时位子
-                                msgUtil.redis_set(taskNode.getResourceId()+"postion",targetStorge.getPointId());
-
-                                // 记录机器人移动到对应设备
-                                ProductionresourcePosition productionresourcePosition = productionresourcePositionMapper.selectOne(new QueryWrap<ProductionresourcePosition>().lambda().eq(ProductionresourcePosition::getStorgeId, targetStorge.getId()));
-                                msgUtil.redis_set("JQR_RESOURCE",productionresourcePosition.getResourceId());
-                            }else{
-                                log.warn("节点{}并发抢占框体机器人移动条件不满足", taskNode.getId());
-                                dataMap.put("result", false);
-                            }
-                        }
-                    }
-                }
-            }
-
         }
         dataMap.put("instructionUrl", instructionUrl);
         return dataMap;
@@ -808,7 +669,7 @@ public class RobotNodeServiceImpl implements NodeOperationService {
             return CollectionUtil.isNotEmpty(robotList) && robotList.size() == 1;
         }else if(BizConstant.ROBOT_TYPE_CACHE.equals(zoneService.getRobotTypebyZone(zoneName))){//手抓必须空闲。
             Map<String, List<ProductionresourcePosition>> jqrMap = robotList.stream().collect(groupingBy(ProductionresourcePosition::getPointId));
-            boolean flag = CollectionUtil.isNotEmpty(robotList) && robotList.size() >1&&jqrMap.containsKey(DemoLineConstant.DEMOLINE_RJQR_ZS);
+            boolean flag = CollectionUtil.isNotEmpty(robotList);
             return flag;
         }
         return true;
@@ -966,122 +827,52 @@ public class RobotNodeServiceImpl implements NodeOperationService {
                     returnMap.put("targetxbk","0");
 
                 }else{
-                    /*
-                    //需要放到线边库
-                    // begin add by yejian on 20220802 for 调度空托盘流转
-                    Long tempAgvTaskStartResourceId = map.get("tempAgvTaskStartResourceId")== null?null:Long.valueOf(map.get("tempAgvTaskStartResourceId").toString());
-                    Long tempAgvTaskEndResourceId = map.get("tempAgvTaskEndResourceId")== null?null:Long.valueOf(map.get("tempAgvTaskEndResourceId").toString());
-                    String tempAgvTaskStartPoint = map.get("tempAgvTaskStartPoint") == null?null:(String)map.get("tempAgvTaskStartPoint");
-                    String tempAgvTaskEndPoint = map.get("tempAgvTaskEndPoint") == null?null:(String)map.get("tempAgvTaskEndPoint");
-                    Storge tempAgvTaskStartPointStorge = map.get("tempAgvTaskStartPointStorge") == null?null:(Storge)map.get("tempAgvTaskStartPointStorge");
-                    Storge tempAgvTaskEndPointStorge = map.get("tempAgvTaskEndPointStorge") == null?null:(Storge)map.get("tempAgvTaskEndPointStorge");
-                    log.info("节点{}接驳位不可用，动态调度接驳位起点{}、终点{}",taskNode.getId(),tempAgvTaskStartPoint,tempAgvTaskEndPoint);
-
-                    if(StringUtils.isNotBlank(tempAgvTaskStartPoint) && StringUtils.isNotBlank(tempAgvTaskEndPoint)){
-                        // 锁定起点终点接驳位
-                        Map agvData = new HashMap();
-                        agvData.put("start", tempAgvTaskStartPoint);
-                        agvData.put("goal", tempAgvTaskEndPoint);
-                        agvData.put("taskId", taskNode.getTaskId());
-                        agvData.put("taskNodeId", taskNode.getId());
-                        // 0:节点自动调度 1：节点资源不可用人工调度
-                        agvData.put("agvTaskType", "1");
-                        JSONObject agvParam = new JSONObject();
-                        agvParam.putAll(agvData);
-                        String zoneType = (null == msgUtil.redis_get(ParameterKey.PARAMETERS)? "": ((Map<String,String>)msgUtil.redis_get(ParameterKey.PARAMETERS)).get(ParameterKey.ZONE_TYPE).toString());
-
-                        // 锁定预占资源
-                        storgeService.lockStorge(tempAgvTaskStartPointStorge, null);
-                        storgeService.lockStorge(tempAgvTaskEndPointStorge, null);
-
-                        // 更新接驳位信息
-                        taskNode.setTargetResourceId(tempAgvTaskEndResourceId);
-                        lastAgvTaskNode.setResourceId(tempAgvTaskEndResourceId);
-                        lastAgvTaskNode.setTargetResourceId(tempAgvTaskStartResourceId);
-                        taskNodeService.updateById(taskNode);
-                        taskNodeService.updateById(lastAgvTaskNode);
-                        log.info("节点{}更新调度agv任务起点{}，终点{}",taskNode.getId(),tempAgvTaskEndResourceId,tempAgvTaskStartResourceId);
-
-                        if(zoneType.equals(ParameterKey.ZONE_SFX)){
-                            agvData.put("transferType","agv");
-                            R addAgvTask = externalApiService.processTransferJob(agvData);
-                        }else{
-                            R addHikTask = agvHikOrderInfoService.addHikTask(agvData);
-                        }
-                    }
-                    // end add by yejian on 20220802 for 调度空托盘流转
-                    */
                     xbkFlag = "1";
                 }
-                // end modify by yejian on 20220513 for agv动态查找满足抽检一个工序需多次调度agv问题
             }
 
         }else {
-            // begin modify by yejian on 20220515 for 下料库位问题修改
-            /*TaskNode beforTaskNode = taskNodeService.getNextNTaskNode(taskNode,-1);
-            //TaskNode baitingTaskNode = taskNodeService.getNextNTaskNode(beforTaskNode,-1);
-            boolean condition = bomProcedureType.equals("下料")  && "04".equals(beforTaskNode.getInterfaceType());
-            log.warn("taskNodeId:{},bomProcedureType：{},interfaceType:{},",taskNode.getId(),bomProcedureType,beforTaskNode.getInterfaceType());
-            //翻面工装下料，节点特殊处理
-            boolean nodeCondition = "4".equals(beforTaskNode.getNodeType()) && bomProcedureType.indexOf("上料")>0 && taskNode.getNodeName().indexOf("立库")>0;
-            if(condition || nodeCondition){
-                // 下料特殊处理，动态查找可用立库位子存放下料后的子盘夹具
-                //处理限高工装下料
-                long storgeId = storgeService.isHeightLimit(taskNode.getCompleteBatchNo())?storgeService.getLikuHeightLimitStock() : storgeService.getLikuStockInList();
-                targetStorge = storgeService.getById(storgeId);
-                returnMap.put("store",targetStorge);
-                returnMap.put("targetxbk","0");
-            }else{*/
-                //目标设备
-                if(resourceId!=null){
-                    String zoneType = (null == msgUtil.redis_get(ParameterKey.PARAMETERS)? "": ((Map<String,String>)msgUtil.redis_get(ParameterKey.PARAMETERS)).get(ParameterKey.ZONE_TYPE).toString());
-                    if(!"放设备清洗站".equals(taskNode.getNodeName()) && zoneType.equals(ParameterKey.ZONE_YJ)){
-                        TTask task = tTaskMapper.selectById(taskNode.getTaskId());
-                        BomProcedure procedure = bomProcedureService.getById(task.getProcedureId());
-                        Productionresource productionresource =  productionresourceBizMapper.selectOne(Wraps.<Productionresource>lbQ().eq(Productionresource::getId,resourceId));
-
-                        // 判断是工件坐标系还是质量测量
-                        if("1".equals(procedure.getThreeDimensionalConf()) || "1".equals(procedure.getThreeDimensionalDeviationConf())){
+            if(resourceId!=null){
+                String zoneType = (null == msgUtil.redis_get(ParameterKey.PARAMETERS)? "": ((Map<String,String>)msgUtil.redis_get(ParameterKey.PARAMETERS)).get(ParameterKey.ZONE_TYPE).toString());
+                if(!"放设备清洗站".equals(taskNode.getNodeName()) && zoneType.equals(ParameterKey.ZONE_YJ)){
+                    TTask task = tTaskMapper.selectById(taskNode.getTaskId());
+                    BomProcedure procedure = bomProcedureService.getById(task.getProcedureId());
+
+                    // 判断是工件坐标系还是质量测量
+                    if("1".equals(procedure.getThreeDimensionalConf()) || "1".equals(procedure.getThreeDimensionalDeviationConf())){
 
-                        }else{
-                            targetList = productionresourcePositionService.getFreeProductionresourcePositionByIds(new String[] {resourceId.toString()});
-                        }
                     }else{
-                        //暂时先用具体类型标识（清洗类型）
-                        targetList = productionresourcePositionService.getFreeProductionresourcePositionByIdsAndType(new String[] {resourceId.toString()},Long.parseLong("1496431321931579392"));
-                        if(CollectionUtil.isEmpty(targetList)){
-                            return null; //必须经过清洗流程
-                        }
+                        targetList = productionresourcePositionService.getFreeProductionresourcePositionByIds(new String[] {resourceId.toString()});
                     }
+                }
 
-                    if(CollectionUtil.isNotEmpty(targetList)){
-                        targetStorge = storgeService.getById(targetList.get(0).getStorgeId());
-                        returnMap.put("storeResourceId",targetList.get(0).getResourceId());
-                        returnMap.put("store",targetStorge);
-                        returnMap.put("targetxbk","0");
-
-                        /*if("1".equals(bomzZone.getRunMode())){//自动模式下，
-                            TaskNode nextTaskNode = taskNodeService.getNextNTaskNode(taskNode,1);
-                            if("04".equals(nextTaskNode.getInterfaceType())){//上料、下料、翻面
-                                xbkFlag = "1";
-                            }
-                        }*/
-                    }else{//需要放到线边库
+                if(CollectionUtil.isNotEmpty(targetList)){
+                    targetStorge = storgeService.getById(targetList.get(0).getStorgeId());
+                    returnMap.put("storeResourceId",targetList.get(0).getResourceId());
+                    returnMap.put("store",targetStorge);
+                    returnMap.put("targetxbk","0");
 
+                    /*if("1".equals(bomzZone.getRunMode())){//自动模式下，
                         TaskNode nextTaskNode = taskNodeService.getNextNTaskNode(taskNode,1);
-                        if("放本序加工设备".equals(taskNode.getNodeName())) {
-                            targetStorge = this.reDispatch(taskNode);
-                            if(!Objects.isNull(targetStorge)){
-                                returnMap.put("storeResourceId",targetList.get(0).getResourceId());
-                                returnMap.put("store",targetStorge);
-                                returnMap.put("targetxbk","0");
-                            }
+                        if("04".equals(nextTaskNode.getInterfaceType())){//上料、下料、翻面
+                            xbkFlag = "1";
+                        }
+                    }*/
+                }else{//需要放到线边库
+
+                    TaskNode nextTaskNode = taskNodeService.getNextNTaskNode(taskNode,1);
+                    if("放本序加工设备".equals(taskNode.getNodeName())) {
+                        targetStorge = this.reDispatch(taskNode);
+                        if(!Objects.isNull(targetStorge)){
+                            returnMap.put("storeResourceId",targetList.get(0).getResourceId());
+                            returnMap.put("store",targetStorge);
+                            returnMap.put("targetxbk","0");
                         }
-
-                        if(CollectionUtil.isEmpty(targetList)) xbkFlag = "1";
                     }
+
+                    if(CollectionUtil.isEmpty(targetList)) xbkFlag = "1";
                 }
-           // }
+            }
         }
 
         if("1".equals(xbkFlag)){//最终放到线边库中

imcs-admin-boot/imcs-business-biz/src/main/resources/mapper_business/base/operationManagementCenter/PlanMapper.xml

@@ -136,11 +136,13 @@
         FROM imcs_b_bom ibb,
             imcs_m_meterial imm,
             imcs_m_meterial_receive_log immrl,
-            imcs_p_plan_product ippp
+            imcs_p_plan_product ippp,
+            imcs_o_order_product ioop
         WHERE 1=1
         AND ibb.id = ippp.bom_id
         and ibb.meterial_id = imm.id
-        AND ibb.meterial_id = immrl.meterial_id
+        and ippp.order_id = ioop.order_id
+        AND ioop.meterial_receive_id = immrl.id
         <if test="id != null and id != ''">
             and ippp.plan_id = #{id}
         </if>

imcs-admin-boot/imcs-business-biz/src/main/resources/mapper_business/base/productionResourceCenter/ProductionresourcePositionMapper.xml

@@ -90,9 +90,6 @@
         <if test="storgeTypeId != null and storgeTypeId != ''">
             and s.storge_type_id = #{storgeTypeId}
         </if>
-        <if test="storgeTypeId == null or storgeTypeId == ''">
-            and s.storge_type_id != '1496431321931579392'
-        </if>
     </select>
     <select id="getStorgeIdByResource" resultType="com.github.zuihou.business.productionResourceCenter.entity.ProductionresourcePosition">
         select * from imcs_p_productionresource_position where 1=1

imcs-admin-boot/imcs-common/src/main/java/com/github/zuihou/common/constant/DictionaryKey.java

@@ -90,7 +90,7 @@ public interface DictionaryKey {
     Map<String, String> YJ_ROBOT_NODES = new HashMap<String, String>(){
         {
             // 云箭配置
-            put("1", "FMS_机器人");
+            put("1", "机器人 200");
             put("2", "保障中心_伺服舵机");
             put("3", "框体_机器人");
             // 示范线配置
@@ -134,7 +134,7 @@ public interface DictionaryKey {
             put("框体类加工单元", "KT_01,KT_02,KT_03");
             put("舱体类加工单元", "CT_01,CT_02,CT_03");
             put("plateAndClamp", "FMS_XBK");
-            put("FMS2.0", "FMS_XBK");
+            put("柔性线", "XBK");
 
             // 示范线配置
 //            put("质量中心-capsule", "XBK_01");

imcs-admin-boot/imcs-tenant-biz/src/main/java/com/github/zuihou/tenant/service/impl/ProductionresourceServiceImpl.java

@@ -553,7 +553,7 @@ public class ProductionresourceServiceImpl extends SuperCacheServiceImpl<Product
             }
             Tenant tenant = tenantService.getById(productionresource.getTenantId());
             Module m = moduleService.getById(productionresource.getModuleId());
-            String tableName = BizConstant.BASE_DATABASE+"_"+tenant.getCode()+"."+BizConstant.DYNTABLE_NAME+m.getNo();
+            String tableName = BizConstant.BASE_DATABASE+"_"+"0000"+"."+BizConstant.DYNTABLE_NAME+m.getNo();
             String resultsql1 = " insert into "+tableName+"(resource_id,"+insertSql+") values("+productionresource.getId()+","+values+")";
             baseMapper.createDynTable(resultsql1);
         }