Merge remote-tracking branch 'origin/master'

src/main/java/com/yunfeiyun/agmp/iots/AgmpIotsApplication.java

@@ -1,5 +1,9 @@
 package com.yunfeiyun.agmp.iots;
 
+import com.yunfeiyun.agmp.common.utils.spring.SpringUtils;
+import com.yunfeiyun.agmp.iots.config.TestConst;
+import com.yunfeiyun.agmp.iots.core.manager.MqttManager;
+import com.yunfeiyun.agmp.iots.device.controller.TestController;
 import org.mybatis.spring.annotation.MapperScan;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -24,6 +28,30 @@ public class AgmpIotsApplication {
     public static void main(String[] args) {
         SpringApplication.run(AgmpIotsApplication.class, args);
         log.info("物联网服务子系统启动成功");
+        for (int i = 0; i < 1; i++) {
+            try {
+                Thread.sleep(10000);
+                log.info("我在这里模拟接收到iotm的消息，下发指令第{}次", i);
+                SpringUtils.getBean(TestController.class).orderTest();
+                // 取消订阅
+                log.info("我在这里模拟解绑topic，下发指令第{}次", i);
+                SpringUtils.getBean(MqttManager.class).topicSingleUnSubscribeDevice(TestConst.connectionId, TestConst.serviceName, TestConst.deviceId);
+                log.info("我在这里模拟解绑topic，等10s收到消息在解绑{}", i);
+
+                Thread.sleep(10000);
+                log.info("我在这里模拟解绑后发消息，");
+                SpringUtils.getBean(TestController.class).orderTest();
+                // 取消订阅
+                log.info("我在这里模拟解绑后再订阅");
+                SpringUtils.getBean(MqttManager.class).topicSingleSubscribeDevice(TestConst.connectionId, TestConst.serviceName, TestConst.deviceId);
+                log.info("我在这里模拟解绑后再订阅发消息，");
+                SpringUtils.getBean(TestController.class).orderTest();
+
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+
+        }
     }
 
 

src/main/java/com/yunfeiyun/agmp/iots/common/modal/IotDeviceconnResVo.java

@@ -14,8 +14,10 @@ import lombok.Data;
 @Data
 public class IotDeviceconnResVo extends IotDeviceconn
 {
-    private String devclassName;
     private String firmName;
     private String devNum;
     private String firmBid;
+    private String devtypeName;
+    private String devtypeCode;
+    private String devClassName;
 }

src/main/java/com/yunfeiyun/agmp/iots/config/TestConst.java

@@ -0,0 +1,23 @@
+package com.yunfeiyun.agmp.iots.config;
+
+import com.yunfeiyun.agmp.common.constant.ErrorCode;
+import com.yunfeiyun.agmp.common.exception.BizException;
+import com.yunfeiyun.agmp.iot.common.constant.devicetype.ServiceNameConst;
+import lombok.extern.slf4j.Slf4j;
+
+@Slf4j
+public class TestConst {
+    // 数据库测报灯的
+    public static final String connectionId="0b006e8d-0193-1000-e000-01aac0a83801";
+    public static final String serviceName= ServiceNameConst.SERVICE_YF_CBD;
+    public static final String deviceId= "864865062128484";
+
+    public static void printError(String msg){
+        //TODO
+        try {
+            throw new BizException(ErrorCode.FAILURE.getCode(), msg);
+        } catch (Exception e) {
+            log.error("{}", e);
+        }
+    }
+}

src/main/java/com/yunfeiyun/agmp/iots/core/cmd/core/task/CmdTaskService.java

@@ -1,7 +1,9 @@
 package com.yunfeiyun.agmp.iots.core.cmd.core.task;
 
 import com.alibaba.fastjson2.JSONObject;
+import com.yunfeiyun.agmp.common.constant.ErrorCode;
 import com.yunfeiyun.agmp.common.enums.RedisCacheKey;
+import com.yunfeiyun.agmp.common.exception.BizException;
 import com.yunfeiyun.agmp.common.framework.manager.RedisCacheManager;
 import com.yunfeiyun.agmp.common.utils.DateUtils;
 import com.yunfeiyun.agmp.common.utils.JSONUtils;
@@ -10,6 +12,7 @@ import com.yunfeiyun.agmp.iot.common.constant.IotErrorCode;
 import com.yunfeiyun.agmp.iot.common.constant.cmd.CmdDef;
 import com.yunfeiyun.agmp.iot.common.constant.cmd.CmdStatus;
 import com.yunfeiyun.agmp.iot.common.constant.cmd.CmdgroupStatus;
+import com.yunfeiyun.agmp.iot.common.constant.devicetype.ServiceNameConst;
 import com.yunfeiyun.agmp.iot.common.domain.IotCmdexec;
 import com.yunfeiyun.agmp.iot.common.domain.IotCmdtask;
 import com.yunfeiyun.agmp.iot.common.domain.IotDevice;
@@ -17,12 +20,14 @@ import com.yunfeiyun.agmp.iot.common.domain.resvo.IotFirmdevResVo;
 import com.yunfeiyun.agmp.iot.common.exception.IotBizException;
 import com.yunfeiyun.agmp.iot.common.model.cmd.CmdGroupModel;
 import com.yunfeiyun.agmp.iot.common.model.task.TaskResult;
+import com.yunfeiyun.agmp.iots.config.TestConst;
 import com.yunfeiyun.agmp.iots.core.cmd.core.serial.SerialTaskModel;
 import com.yunfeiyun.agmp.iots.core.cmd.model.CmdExecModel;
 import com.yunfeiyun.agmp.iots.device.common.Device;
 import com.yunfeiyun.agmp.iot.common.model.cmd.CmdModel;
 import com.yunfeiyun.agmp.iots.core.manager.MqttManager;
 
+import com.yunfeiyun.agmp.iots.exception.IotException;
 import com.yunfeiyun.agmp.iots.service.*;
 import com.yunfeiyun.agmp.iots.service.checker.CmdResultCheckService;
 import lombok.extern.slf4j.Slf4j;
@@ -86,36 +91,21 @@ public class CmdTaskService {
         // 获取完整设备信息
         Map<String, IotDevice> iotDeviceMap = iIotDeviceService.selectIotDeviceByDevBidMap(devBidList);
         // 获取设备厂家信息
-        List<IotFirmdevResVo> iotFirmdevResVoList = iIotFirmdevService.selectIotFirmdevListByDevBidList(devBidList);
-        Map<String, JSONObject> firmdevConfigMap = new HashMap<>();
-        // 生成设备厂家信息map
-        for (IotFirmdevResVo iotFirmdevResVo : iotFirmdevResVoList) {
-            log.info("任务标识:【{}】,装载设备厂商配置信息:【{}】", taskId, iotFirmdevResVo);
-            String k = iotFirmdevResVo.getFirmBid() + iotFirmdevResVo.getDevtypeBid();
-            JSONObject jsonConfig;
-            try {
-                jsonConfig = JSONObject.parseObject(iotFirmdevResVo.getFirmdevCfg());
-            } catch (Exception e) {
-                log.error("请求标识:【{}】,设备厂商配置信息不是标准的JSON格式:{}", e);
-                continue;
-            }
-            firmdevConfigMap.put(k, jsonConfig);
-        }
 
         for (CmdExecModel cmdExecModel : cmdExecModels) {
             CmdModel cmdModel = cmdExecModel.getCmdModel();
             log.info("任务标识:【{}】,开始执行最小任务单元:{}", taskId, cmdModel);
             IotDevice iotDevice = iotDeviceMap.get(cmdModel.getDeviceId());
-            String k = iotDevice.getFirmBid() + iotDevice.getDevtypeBid();
-            JSONObject serviceMap = firmdevConfigMap.get(k);
-            if (serviceMap == null || StringUtils.isEmpty(serviceMap.getString("service"))) {
+            //【需要补充】需要换出来ServiceName
+            TestConst.printError("！！！！！！！！！！【看这里：临时测试】这里的serviceName写死了SERVICE_YF_CBD，对接业务时候换掉，取出来");
+            String serviceName = TestConst.serviceName;
+            if (StringUtils.isEmpty(serviceName)) {
                 cmdExecModel.setCmdStatus(CmdStatus.CMD_STATUS_FAIL.getCode());
                 cmdExecModel.setErrmsg("指令下发失败：设备：" + iotDevice.getDevCode() + "的对应厂家配置异常，请检查");
                 cmdExecModel.setCmdFinishTime(DateUtils.dateTimeNow());
                 cmdResultCheckService.onChecked(cmdExecModel);
                 throw new IotBizException(IotErrorCode.UNKNOWN_DEVICE_FIRM.getCode(), "设备：" + iotDevice.getDevCode() + "的对应厂家配置异常，请检查");
             }
-            String serviceName = serviceMap.getString("service");
             Device device = mqttManager.getDeviceHandler(serviceName);
             if (null == device) {
                 cmdExecModel.setCmdStatus(CmdStatus.CMD_STATUS_FAIL.getCode());
@@ -249,7 +239,7 @@ public class CmdTaskService {
             // 获取当前正在执行的指令集
             List<SerialTaskModel> serialTaskModels = getSerialTaskModels(cmdExecModel, iotCmdtask);
             if (serialTaskModels.isEmpty()) {
-                log.error("执行完了？？？");
+                log.error("执行完了");
                 // 该流程的触发原因：
                 // 1.任务已完成，设备多次上报指令执行结果
                 return;
@@ -429,7 +419,6 @@ public class CmdTaskService {
 
         // 更新任务状态
         log.info("resultCallback 更新任务状态为【{}】，任务id{}", cmdgroupStatus, taskId);
-        //iotCmdtaskService.handleIotCmdTaskResult(taskId, cmdgroupStatus.getCode());
         IotCmdtask iotCmdtask = new IotCmdtask();
         iotCmdtask.setCtBid(taskId);
         iotCmdtask.setCtStatus(cmdgroupStatus.getCode());
@@ -448,7 +437,9 @@ public class CmdTaskService {
         taskResult.setErrMsg(errMsg);
         taskResult.setCompleteDate(DateUtils.dateTimeNow());
         //TODO
-        //   iotsMqService.sendTaskResultMsg(taskResult);
+        // iotsMqService.sendTaskResultMsg(taskResult);
+        TestConst.printError("！！！！！！！！！！【看这里：临时测试】需要完善mq发送回执消息");
+
     }
 
     private void resetResultCallback(CmdExecModel cmdExecModel, CmdgroupStatus cmdgroupStatus) {
@@ -459,7 +450,6 @@ public class CmdTaskService {
 
         // 更新任务状态
         log.info("resetResultCallback 更新任务状态为【{}】，任务id{}", cmdgroupStatus, cmdExecModel.getTaskUuid());
-        //iotCmdtaskService.handleIotCmdTaskResult(cmdExecModel.getTaskUuid(), cmdgroupStatus.getCode());
 
         IotCmdtask findItem = iotCmdtaskService.selectIotCmdtaskByCtBid(cmdExecModel.getTaskUuid());
         if (findItem == null) {
@@ -486,12 +476,13 @@ public class CmdTaskService {
         taskResult.setCompleteDate(DateUtils.dateTimeNow());
 
         JSONObject ext = new JSONObject();
-        ext.put("ctDescribe",findItem.getCtDescribe());
-        ext.put("ctDevtype",findItem.getCtDevtype());
-        ext.put("ctDevcode",findItem.getCtDevcode());
+        ext.put("ctDescribe", findItem.getCtDescribe());
+        ext.put("ctDevtype", findItem.getCtDevtype());
+        ext.put("ctDevcode", findItem.getCtDevcode());
         taskResult.setExtraBody(ext);
         // TODO
         // iotsMqService.sendTaskResultMsg(taskResult);
+        TestConst.printError("！！！！！！！！！！【看这里：临时测试】需要完善mq发送回执消息");
     }
 
     public static long getTimeDifference(String datetime1, String datetime2) {

src/main/java/com/yunfeiyun/agmp/iots/core/init/AfterRunner.java

@@ -23,18 +23,18 @@ public class AfterRunner implements ApplicationRunner {
     public void run(ApplicationArguments args) throws Exception {
         log.info("【数据初始化】【执行设备同步】");
         try {
-            deviceScheduler.synMqDevice();
+            //deviceScheduler.synMqDevice();
         } catch (Exception e) {
             log.error("【数据初始化】【执行物候设备同步】异常", e);
         }
         try {
-            deviceScheduler.autoInsertSfDevice();
+            //deviceScheduler.autoInsertSfDevice();
         } catch (Exception e) {
             log.error("【数据初始化】【执行宏泰设备同步】异常", e);
         }
 
         try {
-            deviceScheduler.autoInsertBySfDevice();
+            //deviceScheduler.autoInsertBySfDevice();
         } catch (Exception e) {
             log.error("【数据初始化】【执行博云设备同步】异常", e);
         }

src/main/java/com/yunfeiyun/agmp/iots/core/manager/MqttManager.java

@@ -19,6 +19,7 @@ import lombok.extern.slf4j.Slf4j;
 import org.eclipse.paho.client.mqttv3.MqttClient;
 import org.eclipse.paho.client.mqttv3.MqttException;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.scheduling.annotation.Async;
 import org.springframework.stereotype.Component;
 
 import javax.annotation.Resource;
@@ -54,8 +55,7 @@ public class MqttManager {
     @Resource
     private Map<String, Device> deviceHandlerMap;
 
-    @Resource
-    private CmdResultCheckService cmdResultCheckService;
+
 
 
     /**
@@ -78,7 +78,7 @@ public class MqttManager {
      * @throws MqttException
      */
     public void buildMqttConnection(IotDeviceconnResVo iotDeviceconnResVo, JSONObject jsonConfig) throws MqttException {
-        log.info("【开始构建MQTT连接】 tosDeviceTypeName: {}, tosDeviceTypeId:{}, jsonConfig: {}", iotDeviceconnResVo.getDevclassName(), iotDeviceconnResVo.getDevtypeBid(), jsonConfig);
+        log.info("【开始构建MQTT连接】 tosDeviceTypeName: {}, tosDeviceTypeId:{}, jsonConfig: {}", iotDeviceconnResVo.getDevtypeName(), iotDeviceconnResVo.getDevtypeBid(), jsonConfig);
 
         // 构建配置
         MqttConfig cfgYf = buildMqttConfig(iotDeviceconnResVo, jsonConfig);
@@ -99,19 +99,19 @@ public class MqttManager {
         log.info("【创建MqttCore实例】 mqttCore: {}", mqttCore);
 
         // 查询topics【需要实现：重新更改获取该型号下的设备】
-        //String[] topics = deviceTopicService.getBatchTopic(serviceName, deviceTopicService.getDeviceIdByFirmBizId(firmBizId, deviceTypeId));
-        String[] topics = deviceTopicService.getBatchTopic(serviceName, new String[]{"", "", ""});
+        String connectionId=iotDeviceconnResVo.getDevconnBid();
+        String[] topics = deviceTopicService.getBatchTopic(serviceName, deviceTopicService.getDeviceCodesByConectionId(connectionId));
         cfgYf.setSubTopic(topics);
         cfgYf.setServiceName(serviceName);
         log.info("【初始化厂商加载配置】 {} {} {}", firmName, type, Arrays.toString(topics));
 
-        // 处理连接ID的逻辑
-        log.info("【添加公共连接】 connectionId: connectionId");
-        addConnectionMap("connectionId", mqttCore);
+        // 处理连接ID的逻辑 IP+port+name
+        log.info("【添加公共连接】 connectionId: {}",connectionId);
+        addConnectionMap(connectionId, mqttCore);
 
         // 构建MqttCore
         try {
-            mqttCore.buildMqttCore(cfgYf, cmdResultCheckService);
+            mqttCore.buildMqttCore(cfgYf);
             log.info("【成功构建MqttCore】 mqttCore: {}", mqttCore);
         } catch (MqttException e) {
             log.error("【构建MqttCore失败】 异常信息: {}", e.getMessage(), e);
@@ -177,7 +177,7 @@ public class MqttManager {
         cfgYf.setType(type);
         //其他信息
         cfgYf.setFirmName(iotDeviceconnResVo.getFirmName());
-        cfgYf.setDeviceType(DevType.valueOfCode(iotDeviceconnResVo.getDevtypeBid()));
+        cfgYf.setDeviceType(iotDeviceconnResVo.getDevtypeName());
         cfgYf.setDeviceTypeBizId(iotDeviceconnResVo.getDevtypeBid());
 
         cfgYf.setIp(jsonConfig.getString("ip"));

src/main/java/com/yunfeiyun/agmp/iots/core/manager/test/MqttTest.java

@@ -0,0 +1,8 @@
+package com.yunfeiyun.agmp.iots.core.manager.test;
+
+import org.springframework.stereotype.Service;
+
+@Service
+public class MqttTest {
+
+}

src/main/java/com/yunfeiyun/agmp/iots/core/mqtt/DeviceTopicService.java

@@ -11,6 +11,7 @@ import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
 import javax.annotation.Resource;
+import java.util.ArrayList;
 import java.util.List;
 
 
@@ -78,7 +79,7 @@ public class DeviceTopicService {
             case ServiceNameConst.SERVICE_YF_XYCB_2: {
                 return getYfXycb2BatchSubTopic(deviceId);
             }
-            case ServiceNameConst.SERVICE_BIG_DATA_MONITOR:{
+            case ServiceNameConst.SERVICE_BIG_DATA_MONITOR: {
                 return getHKBatchSubTopic();
             }
             case ServiceNameConst.SERVICE_XPH:
@@ -100,7 +101,7 @@ public class DeviceTopicService {
             topics = new String[iotDeviceList.size()];
             for (int i = 0; i < iotDeviceList.size(); i++) {
                 // 只接受上报的订阅
-                topics[i] = IotMqttConstant.MonitorPhotoTopic.TOPIC_MONITOR_PHOTO_PREFIX + iotDeviceList.get(i).getDevCode() ;
+                topics[i] = IotMqttConstant.MonitorPhotoTopic.TOPIC_MONITOR_PHOTO_PREFIX + iotDeviceList.get(i).getDevCode();
             }
         }
         return topics;
@@ -173,19 +174,20 @@ public class DeviceTopicService {
         return getTopics(deviceId, topicArray);
     }
 
-    private String[] getTopics(String[] deviceId, String[] topicArray){
+    private String[] getTopics(String[] deviceId, String[] topicArray) {
         String[] topics = new String[0];
         if (deviceId != null) {
             int topicLen = topicArray.length;
             topics = new String[deviceId.length * topicLen];
             for (int i = 0; i < deviceId.length; i++) {
-                for(int x = 0; x < topicLen; x++){
+                for (int x = 0; x < topicLen; x++) {
                     topics[i * topicLen + x] = topicArray[x] + deviceId[i];
                 }
             }
         }
         return topics;
     }
+
     /**
      * 获取性诱2.0设备 topic
      *
@@ -239,4 +241,18 @@ public class DeviceTopicService {
         };
         return getTopics(deviceId, topicArray);
     }
+
+    /**
+     * 根据id获取设备信息
+     *
+     * @param connectionId
+     * @return
+     */
+    public String[] getDeviceCodesByConectionId(String connectionId) {
+        List<String> ids = iotDeviceService.getDeviceCodesByConectionId(connectionId);
+        if (ids == null || ids.isEmpty()) {
+            return new String[]{};
+        }
+        return ids.toArray(new String[]{});
+    }
 }

src/main/java/com/yunfeiyun/agmp/iots/core/mqtt/network/MqttConfig.java

@@ -18,12 +18,18 @@ public class MqttConfig {
     private String username;
     private String password;
     /**
-     * 设备类型 ，用于标明实现类
-     * 测报灯：YF-CBD
+     * 设备型号名称
      */
     private String deviceType;
+    /**
+     * 设备型号的id
+     */
     private String deviceTypeBizId;
+    /**
+     * 厂家id
+     */
     private String firmBizId;
+
     private String firmName;
 
     private MqttClient mqttClient;
@@ -33,7 +39,9 @@ public class MqttConfig {
      * 上报的topic
      */
     private String[] subTopic;
-
+    /**
+     * 标识实现类
+     */
     private String serviceName;
     private String type;
 }

src/main/java/com/yunfeiyun/agmp/iots/core/mqtt/network/MqttCore.java

@@ -111,13 +111,13 @@ public class MqttCore {
      * @param mqttConfig
      * @throws MqttException
      */
-    public void buildMqttCore(MqttConfig mqttConfig, CmdResultCheckService cmdResultCheckService) throws MqttException {
+    public void buildMqttCore(MqttConfig mqttConfig) throws MqttException {
         log.info("【初始化】MQTT CORE {},{},{},{},{},", mqttConfig.getDeviceType(), mqttConfig.getIp(), mqttConfig.getPort(), mqttConfig.getUsername(), mqttConfig.getPassword());
         this.mqttConfig = mqttConfig;
         buildClient();
         connection();
         buildPublisher();
-        buildSubscriber(cmdResultCheckService);
+        buildSubscriber();
 
     }
 
@@ -155,9 +155,9 @@ public class MqttCore {
      *
      * @throws MqttException
      */
-    private void buildSubscriber(CmdResultCheckService cmdResultCheckService) throws MqttException {
+    private void buildSubscriber() throws MqttException {
         MqttSubscriber mqttSubscriber = new MqttSubscriber();
-        mqttSubscriber.init(this, cmdResultCheckService);
+        mqttSubscriber.init(this);
         this.mqttSubscriber = mqttSubscriber;
         log.info("【初始化】构建 MQTT subscriber");
     }

src/main/java/com/yunfeiyun/agmp/iots/core/mqtt/network/MqttSubscriber.java

@@ -20,25 +20,17 @@ public class MqttSubscriber implements MqttCallbackExtended {
 
     private MqttCore mqttCore;
 
-    private CmdResultCheckService checkService;
 
-
-    public void init(MqttCore mqttCore, CmdResultCheckService cmdResultCheckService) throws MqttException {
+    public void init(MqttCore mqttCore) throws MqttException {
         this.mqttCore = mqttCore;
         this.mqttClient = mqttCore.getClient();
-        //this.checkService = cmdResultCheckService;
-
-        this.checkService = SpringUtils.getBean(CmdResultCheckService.class);
-
         String[] topics = mqttCore.getSubTopic();
         mqttClient.setCallback(this);
         for (String topic : topics) {
-
             //TODO 测试设备乱发离线指令，暂时不订阅它
             if ("/yfkj/cbd/offline/861551058867599".equals(topic)) {
                 continue;
             }
-
             mqttClient.subscribe(topic);
             log.debug("mqtt 主题已订阅 {},{}", mqttCore.getServiceType(), topic);
         }
@@ -70,7 +62,7 @@ public class MqttSubscriber implements MqttCallbackExtended {
             log.info("【上报数据：处理结果】{}", result);
             //如果是“设备属性”消息，进行执行结果检查
             if (device.isDeviceProps(obj)) {
-                checkService.check(device.findIotDevice(topic, obj), obj);
+                SpringUtils.getBean(CmdResultCheckService.class).check(device.findIotDevice(topic, obj), obj);
             } else {
                 log.error("其它数据");
             }

src/main/java/com/yunfeiyun/agmp/iots/core/tcp/NettyServer.java

@@ -53,7 +53,7 @@ public class NettyServer {
      *
      * @throws InterruptedException
      */
-    @PostConstruct
+    //@PostConstruct
     public void start() throws InterruptedException {
         ServerBootstrap bootstrap = new ServerBootstrap();
         bootstrap.group(boss, work)

src/main/java/com/yunfeiyun/agmp/iots/device/controller/TestController.java

@@ -0,0 +1,88 @@
+package com.yunfeiyun.agmp.iots.device.controller;
+
+import com.yunfeiyun.agmp.common.core.domain.AjaxResult;
+import com.yunfeiyun.agmp.common.utils.JSONUtils;
+import com.yunfeiyun.agmp.iot.common.constant.devicetype.ServiceNameConst;
+import com.yunfeiyun.agmp.iot.common.model.cmd.CmdGroupModel;
+import com.yunfeiyun.agmp.iots.core.cmd.core.CmdDispatcherService;
+import com.yunfeiyun.agmp.iots.core.manager.MqttManager;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.*;
+
+
+/**
+ * 设备相关接口
+ */
+@RestController
+@RequestMapping("test")
+@Slf4j
+public class TestController {
+
+
+    @Autowired
+    private MqttManager mqttManager;
+
+
+    @Autowired
+    private CmdDispatcherService cmdDispatcherService;
+
+    /**
+     * 该方法模拟接收到mq的消息解析发送
+     *
+     * @param
+     * @return
+     * @throws Exception
+     */
+    @GetMapping("/cbd/test/cmd")
+    public AjaxResult orderTest() {
+        log.info("测试发送指令，测报灯");
+        String msg = "{\n" +
+                "\t\"taskUuid\": \"c164133a-0192-1000-e001-6ae6c0a801e6\",\n" +
+                "\t\"taskDesc\": null,\n" +
+                "\t\"cmdModels\": [\n" +
+                "\t\t[{\n" +
+                "\t\t\t\"ctBid\": null,\n" +
+                "\t\t\t\"ceBid\": null,\n" +
+                "\t\t\t\"deviceId\": \"25470430-0191-1000-e000-50297f000001\",\n" +
+                "\t\t\t\"iotDevice\": null,\n" +
+                "\t\t\t\"clogSendresult\": null,\n" +
+                "\t\t\t\"clogSendresultContent\": null,\n" +
+                "\t\t\t\"clogValidresult\": null,\n" +
+                "\t\t\t\"clogDesc\": null,\n" +
+                "\t\t\t\"tag\": null,\n" +
+                "\t\t\t\"delay\": null,\n" +
+                "\t\t\t\"durationTime\": null,\n" +
+                "\t\t\t\"finalStatus\": false,\n" +
+                "\t\t\t\"needcheckStatus\": false,\n" +
+                "\t\t\t\"timeout\": 10,\n" +
+                "\t\t\t\"dockingMode\": null,\n" +
+                "\t\t\t\"cmdFeedback\": null,\n" +
+                "\t\t\t\"cmdDistribution\": {\n" +
+                "\t\t\t\t\"func\": \"refresh\",\n" +
+                "\t\t\t\t\"retry\": 5,\n" +
+                "\t\t\t\t\"jsons\": {\n" +
+                "\t\t\t\t\t\"cmd\": \"read\",\n" +
+                "\t\t\t\t\t\"ext\": \"data\"\n" +
+                "\t\t\t\t}\n" +
+                "\t\t\t}\n" +
+                "\t\t}]\n" +
+                "\t],\n" +
+                "\t\"resetCmdModels\": null,\n" +
+                "\t\"requestId\": \"9828935b-ee4e-41ff-98b4-e60ba99336e2\",\n" +
+                "\t\"receiptAddr\": null,\n" +
+                "\t\"devCode\": \"864865062128484\",\n" +
+                "\t\"ctBiztype\": \"3\",\n" +
+                "\t\"ctBiztitle\": \"测报灯：864865062128484\",\n" +
+                "\t\"ctParam\": \"【测报灯控制】设备ID:25470430-0191-1000-e000-50297f000001,刷新数据;\",\n" +
+                "\t\"ctDevtype\": \"3\",\n" +
+                "\t\"ctDelayTime\": null,\n" +
+                "\t\"cid\": \"1\"\n" +
+                "}";
+        CmdGroupModel cmdGroupModel = JSONUtils.toObject(msg, CmdGroupModel.class);
+        cmdDispatcherService.handleCmd(cmdGroupModel);
+        // 模拟设备指令接入
+        //mqttManager.getDeviceHandler(ServiceNameConst.SERVICE_YF_CBD).sendCmd(null);
+        return AjaxResult.success();
+    }
+}

src/main/java/com/yunfeiyun/agmp/iots/device/mapper/IotDeviceMapper.java

@@ -95,6 +95,8 @@ public interface IotDeviceMapper {
     List<IotDevice> selectIotDeviceByIotDeviceDTO(IotDeviceDto iotDeviceDto);
 
     int updateIotDeviceStatusByType(@Param("devStatus") String devStatus,@Param("firmBid") String firmBid,@Param("devtypeBid")String devtypeBid);
+
+    List<String> getDeviceCodesByConectionId(@Param("connectionId") String connectionId);
 }
 
 

src/main/java/com/yunfeiyun/agmp/iots/device/serviceImp/CqCbdDeviceImpl.java

@@ -15,6 +15,7 @@ import com.yunfeiyun.agmp.iot.common.model.cmd.CmdModel;
 import com.yunfeiyun.agmp.iot.common.service.MongoService;
 import com.yunfeiyun.agmp.iot.common.service.IotAddressService;
 import com.yunfeiyun.agmp.iot.common.constant.devicetype.ServiceNameConst;
+import com.yunfeiyun.agmp.iots.config.TestConst;
 import com.yunfeiyun.agmp.iots.device.domain.cbd.YfCbdMsgUtil;
 import com.yunfeiyun.agmp.iots.device.domain.cbd.YfCbdTakephotoMsg;
 import com.yunfeiyun.agmp.iots.device.service.*;
@@ -76,18 +77,19 @@ public class CqCbdDeviceImpl implements ICbdDevice {
     @Autowired
     private IotDeviceAddressService iotDeviceAddressService;
 
+    String connectionId = TestConst.connectionId;
     @Override
     public Object sendCmd(CmdModel cmdModel) throws Exception {
-        log.info("【CBD】收到指令 任务 cmdModel={}", cmdModel);
+        log.info("【测报灯】发送指令 任务 cmdModel={}", cmdModel);
 
         // 获取执行的指令
         CmdModel.Cmd cmdDistribution = cmdModel.getCmdDistribution();
         // 获取执行的方法 ，方法可以通过反射获取执行，也可以临时case 匹配
         String methodName = cmdModel.getCmdDistribution().getFunc();
 
+
         String mqttMsgContent = "";
         String clogSendresult = "发送指令成功";
-        ;
 
         switch (methodName) {
             case CmdDef.YfCbdCmdDef.CMD_REQ_DATA:
@@ -125,11 +127,11 @@ public class CqCbdDeviceImpl implements ICbdDevice {
                 break;
             }
         }
+        String topic = IotMqttConstant.YFCbdTopic.TOPIC_CBD_CMD_PREFIX + cmdModel.getIotDevice().getDevCode();
+        log.info("！！！！！！！！！！【看这里：临时测试】这里的connectionId写死了，对接业务时候换掉，取出来真实的");
+        mqttManager.publishMsg(connectionId, topic, mqttMsgContent);
 
-        MqttPublisher mqttPublisher = mqttManager.getPublisherByService(SERVICE_NAME);
-        mqttPublisher.publish(IotMqttConstant.YFCbdTopic.TOPIC_CBD_CMD_PREFIX + cmdModel.getIotDevice().getDevCode(), mqttMsgContent);
-
-        log.info("【CBD】发送指令完毕！");
+        log.info("【CBD】发送指令完毕！connectionId:{},topic :{} mqttMsgContent: {}",connectionId,topic, mqttMsgContent);
 
         cmdModel.setClogSendresult(clogSendresult);
         cmdModel.setClogDesc(mqttMsgContent);
@@ -206,9 +208,10 @@ public class CqCbdDeviceImpl implements ICbdDevice {
     }
 
     public void cmdData(JSONObject ext, String devUpdateddate) throws Exception {
-        log.info("测报灯数据解析 {}", ext.toString());
-        String devtypeBid = mqttManager.getDeviceTypeBizId(SERVICE_NAME);
-        String firmBid = mqttManager.getFirmBizId(SERVICE_NAME);
+        log.info("【测报灯】数据解析 {}", ext.toString());
+        TestConst.printError("！！！！！！！！！！【看这里：临时测试】这里的connectionId写死了，对接业务时候换掉，取出来");
+        String devtypeBid = mqttManager.getDeviceTypeBizId(connectionId);
+        String firmBid = mqttManager.getFirmBizId(connectionId);
         boolean isCbd = true;
         String vtype = ext.getString("vtype");
         if (ext.containsKey("dat_f")) {
@@ -304,11 +307,11 @@ public class CqCbdDeviceImpl implements ICbdDevice {
 
     @Override
     public Object receiveData(String topic, JSONObject dataJson) throws Exception {
-        log.debug("测报灯实现类  处理收到的 设备上报数据 {}", dataJson.toString());
+        log.info("【测报灯】收到的 设备上报数据 {}", dataJson.toString());
         // 接收设备上报数据后的处理逻辑
         String devUpdateddate = dataJson.getString("devUpdateddate");
-        if(StringUtils.isEmpty(devUpdateddate)){
-            devUpdateddate= DateUtils.dateTimeNow();
+        if (StringUtils.isEmpty(devUpdateddate)) {
+            devUpdateddate = DateUtils.dateTimeNow();
         }
         if (dataJson.containsKey("Image")) {
             Object result = this.receivePicData(dataJson, devUpdateddate);
@@ -335,7 +338,7 @@ public class CqCbdDeviceImpl implements ICbdDevice {
     }
 
     @Override
-    public Object receivePicData(JSONObject jsonObject, String devUpdateddate){
+    public Object receivePicData(JSONObject jsonObject, String devUpdateddate) {
         String devtypeBid = mqttManager.getDeviceTypeBizId(SERVICE_NAME);
         String firmBid = mqttManager.getFirmBizId(SERVICE_NAME);
         String deviceTypeId = jsonObject.getString("device_type_id");
@@ -381,8 +384,8 @@ public class CqCbdDeviceImpl implements ICbdDevice {
     @Override
     public IotDevice findIotDevice(String topic, JSONObject jobjMsg) {
         String devCode = topic.substring(topic.lastIndexOf("/") + 1);
-        String devtypeBid = mqttManager.getDeviceTypeBizId(SERVICE_NAME);
-        String firmBid = mqttManager.getFirmBizId(SERVICE_NAME);
+        String devtypeBid = mqttManager.getDeviceTypeBizId(connectionId);
+        String firmBid = mqttManager.getFirmBizId(connectionId);
         //查询
         IotDevice ret = iIotDeviceService.selectIotDeviceByTypeFirmCode(devtypeBid, firmBid, devCode);
         log.debug("查到了一个iotdevice {}", ret);

src/main/java/com/yunfeiyun/agmp/iots/service/IIotDeviceService.java

@@ -129,5 +129,7 @@ public interface IIotDeviceService {
     Map<String, List<IotDevice>> getXphHttpDeviceMapByDevtypeBids(String firmBizId, List<String> devtypeBids);
 
     public void updateIotDeviceBatch(List<IotDevice> iotDeviceList);
+
+    List<String> getDeviceCodesByConectionId(String connectionId);
 }
 

src/main/java/com/yunfeiyun/agmp/iots/service/checker/CmdResultCheckService.java

@@ -4,26 +4,23 @@ import com.alibaba.fastjson2.JSONObject;
 import com.yunfeiyun.agmp.iot.common.constant.devicetype.IotDeviceDictConst;
 import com.yunfeiyun.agmp.iot.common.constant.cmd.CmdStatus;
 import com.yunfeiyun.agmp.iot.common.domain.IotDevice;
+import com.yunfeiyun.agmp.iots.config.TestConst;
 import com.yunfeiyun.agmp.iots.core.cmd.core.CmdDispatcherService;
 import com.yunfeiyun.agmp.iots.core.cmd.model.CmdExecModel;
-import com.yunfeiyun.agmp.iots.service.IIotDeviceService;
 import com.yunfeiyun.agmp.iots.core.cmd.core.CmdCheckScheduledFuture;
 import com.yunfeiyun.agmp.iots.core.cmd.core.CmdResultTimedout;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.http.util.TextUtils;
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
-import javax.annotation.Resource;
 import java.util.concurrent.*;
 
 @Slf4j
 @Service
 public class CmdResultCheckService {
 
-    @Resource
-    private IIotDeviceService iIotDeviceService;
-
-    @Resource
+    @Autowired
     private CmdDispatcherService cmdDispatcherService;
 
 
@@ -54,7 +51,7 @@ public class CmdResultCheckService {
 
         String deviceID = cmdExecModel.getCmdModel().getDeviceId();
         log.info("任务id【{}】Checker : 创建, 设备id:{}, 指令：{}", cmdExecModel.getTaskUuid(), deviceID, cmdExecModel.getCmdModel().getCmdDistribution());
-
+        //这里需要该，根据新的判断逻辑，创建对应的checker
         CmdResultChecker cmdResultChecker = newChecker(iotDevice, cmdExecModel);
         log.info("任务id【{}】,创建结果：{}", cmdExecModel.getTaskUuid(), cmdResultChecker);
 
@@ -62,14 +59,14 @@ public class CmdResultCheckService {
             log.error("任务id【{}】,【指令结果检查器】创建异常！");
             return;
         }
-
-        if (hmChecker.get(deviceID) != null) {
-            hmChecker.get(deviceID).put(cmdExecModel.getCeBid(), cmdResultChecker);
+        ConcurrentHashMap<String, CmdResultChecker> checkerMap = hmChecker.get(deviceID);
+        if (checkerMap != null) {
+            checkerMap.put(cmdExecModel.getCeBid(), cmdResultChecker);
             log.info("任务id【{}】,在已有list中添加item", cmdExecModel.getTaskUuid());
         } else {
-            ConcurrentHashMap<String, CmdResultChecker> list = new ConcurrentHashMap<>();
-            list.put(cmdExecModel.getCeBid(), cmdResultChecker);
-            hmChecker.put(deviceID, list);
+            checkerMap = new ConcurrentHashMap<>();
+            checkerMap.put(cmdExecModel.getCeBid(), cmdResultChecker);
+            hmChecker.put(deviceID, checkerMap);
             log.info("任务id【{}】,新建list，在里面添加一个item", cmdExecModel.getTaskUuid());
         }
 
@@ -80,12 +77,13 @@ public class CmdResultCheckService {
                 , TimeUnit.SECONDS
         );
         CmdCheckScheduledFuture future = new CmdCheckScheduledFuture(cmdExecModel, scheduledFuture);
-        if (hmFuture.get(deviceID) != null) {
-            hmFuture.get(deviceID).put(cmdExecModel.getCeBid(), future);
+        ConcurrentHashMap<String, CmdCheckScheduledFuture> checkScheduledFutureMap = hmFuture.get(deviceID);
+        if (checkScheduledFutureMap != null) {
+            checkScheduledFutureMap.put(cmdExecModel.getCeBid(), future);
         } else {
-            ConcurrentHashMap<String, CmdCheckScheduledFuture> list = new ConcurrentHashMap<>();
-            list.put(cmdExecModel.getCeBid(), future);
-            hmFuture.put(deviceID, list);
+            checkScheduledFutureMap = new ConcurrentHashMap<>();
+            checkScheduledFutureMap.put(cmdExecModel.getCeBid(), future);
+            hmFuture.put(deviceID, checkScheduledFutureMap);
         }
         log.debug("任务id【{}】,指令执行结果检查器 已添加  指令：{}", cmdExecModel.getTaskUuid(), cmdExecModel);
     }
@@ -96,6 +94,10 @@ public class CmdResultCheckService {
      * @param cmdExecModel
      */
     public void onChecked(CmdExecModel cmdExecModel) {
+        if (true) {
+            TestConst.printError("！！！！！！！！！！【看这里：临时测试】checker 因为iots直接下发指令测试，没有塞缓存task，先强制关闭，联调到iotm iots，再打开");
+            return;
+        }
         if (cmdExecModel == null) {
             log.error("cmdExceModel is null");
             return;
@@ -193,15 +195,9 @@ public class CmdResultCheckService {
     private void removeChecker(CmdExecModel cmdExecModel) {
         CmdResultChecker findItem = null;
         ConcurrentHashMap<String, CmdResultChecker> list = hmChecker.get(cmdExecModel.getCmdModel().getDeviceId());
-        log.info("111遍历cheker{}", list);
         if (list != null) {
-            log.info("222遍历cheker{}", list);
             for (CmdResultChecker item : list.values()) {
-                log.info("设备标识{},当前指令执行bid{},当前检查器关联指令执行{}"
-                        , cmdExecModel.getCmdModel().getDeviceId()
-                        , cmdExecModel.getCeBid()
-                        , item.getCmdExecModel()
-                );
+                log.info("设备标识{},当前指令执行bid{},当前检查器关联指令执行{}", cmdExecModel.getCmdModel().getDeviceId(), cmdExecModel.getCeBid(), item.getCmdExecModel());
                 if (cmdExecModel.getCeBid().equals(item.getCmdExecModel().getCeBid())) {
                     findItem = item;
                     break;
@@ -238,11 +234,10 @@ public class CmdResultCheckService {
      * @return
      */
     private CmdResultChecker newChecker(IotDevice iotDevice, CmdExecModel cmdExecModel) {
-        //TODO 临时逻辑  ，需要机制缓存相关对应关系
         if (IotDeviceDictConst.TYPE_YF_CBD.equals(iotDevice.getDevtypeBid()) || IotDeviceDictConst.TYPE_YF_GKCBD.equals(iotDevice.getDevtypeBid())) {
-            return new YfCbdCmdResultChecker(cmdExecModel, this, cmdDispatcherService);
-        }  else if (IotDeviceDictConst.TYPE_YF_JKSB.equals(iotDevice.getDevtypeBid())) {
-            return new EzvizCmdResultChecker(cmdExecModel, this, cmdDispatcherService);
+            return new YfCbdCmdResultChecker(cmdExecModel);
+        } else if (IotDeviceDictConst.TYPE_YF_JKSB.equals(iotDevice.getDevtypeBid())) {
+            return new EzvizCmdResultChecker(cmdExecModel);
         }
         return null;
     }

src/main/java/com/yunfeiyun/agmp/iots/service/checker/CmdResultChecker.java

@@ -1,7 +1,6 @@
 package com.yunfeiyun.agmp.iots.service.checker;
 
 
-
 import com.alibaba.fastjson2.JSONObject;
 import com.yunfeiyun.agmp.common.utils.spring.SpringUtils;
 import com.yunfeiyun.agmp.iot.common.constant.cmd.CmdStatus;
@@ -24,116 +23,74 @@ import java.util.concurrent.ScheduledFuture;
 
 /**
  * 单条指令执行结果检查器基类
- *
- *
+ * <p>
+ * <p>
  * 当指令集中存在“结束指令”时：
- *
+ * <p>
  * 当单个“普通指令（未标记为finally）”执行成功时，执行“指令集继续处理”；
  * 当单个“普通指令（未标记为finally）”执行出错、失败、超时时，执行finally指令组；
  * 当finally指令组（一组指令，可能只有一个，本组的全部指令）执行成功时，标志着整个任务执行成功（如果是因为前面的指令出错、失败、超时等原因直接跳到finally指令的，整个任务的状态为“已失败”），执行出错、失败、超时时，标志着整个任务状态为“复位失败”
- *
+ * <p>
  * 当指令集中不存在“结束指令”时：
- *  当单个“普通指令“执行成功时，执行“指令集继续处理”；
- *  当单个“普通指令”执行出错、失败、超时时，认为整个任务执行失败；
- *  当最后一组指令（可能只有一个）全部执行成功时，认为整个任务执行成功。
- *
- *
+ * 当单个“普通指令“执行成功时，执行“指令集继续处理”；
+ * 当单个“普通指令”执行出错、失败、超时时，认为整个任务执行失败；
+ * 当最后一组指令（可能只有一个）全部执行成功时，认为整个任务执行成功。
  */
 @Data
 @Slf4j
-public class CmdResultChecker{
-
-
+public class CmdResultChecker {
 
     /**
      * 该条指令
      */
     private CmdExecModel cmdExecModel;
 
-    //private ScheduledFuture<Boolean> timeoutFuture;
-
-    private CmdDispatcherService cmdDispatcherService;
-
-    private CmdResultCheckService cmdResultCheckService;
-
     /**
      * 知道结果或等待结果超时后，变更此标记为true
      */
     private boolean isDone;
 
-    public CmdResultChecker(CmdExecModel cmdExecModel,CmdResultCheckService cmdResultCheckService, CmdDispatcherService cmdDispatcherService) {
+    public CmdResultChecker(CmdExecModel cmdExecModel) {
         this.cmdExecModel = cmdExecModel;
-        //this.cmdResultCheckService = cmdResultCheckService;
-        this.cmdResultCheckService = SpringUtils.getBean(CmdResultCheckService.class);
-        this.cmdDispatcherService = cmdDispatcherService;
     }
 
-    public void configRetry(int retry){
+    public void configRetry(int retry) {
 
     }
 
-    public void configTimedout(int timedout){
+    public void configTimedout(int timedout) {
 
     }
 
     /**
      * 有的设备需要发送查询指令，以触发设备立即上报数据
      */
-    public void reqData(){
+    public void reqData() {
 
     }
 
-    /**
-     * 启动
-     */
-/*    public void start(){
-
-        //执行结果检查是被动的：设备下次上报数据时执行
-
-        //超时处理是主动的
-        try {
-            Boolean isTimeout = timeoutFuture.get();
-
-            if(isTimeout){
-                onResult(CmdStatus.CMD_STATUS_FAIL,"等待指令["+cmdExecModel.getCmdModel().getTag()+"]执行结果超时");
-            }
-        } catch (InterruptedException e) {
-            throw new RuntimeException(e);
-        } catch (ExecutionException e) {
-            throw new RuntimeException(e);
-        }
-    }*/
 
     /**
      * 得到单条指令执行结果后的处理
      */
-    public void onResult(CmdStatus cmdStatus, String errMsg){
-
-        log.debug(""+this+", "+cmdResultCheckService+"，得到指令的执行结果："+cmdStatus+"，错误信息（如果有的话）："+errMsg);
-
-        isDone = true;  //checker一旦得到结果，它的使命就结束了
-
-        //TODO 更新指令执行记录表
+    public void onResult(CmdStatus cmdStatus, String errMsg) {
+        log.debug("得到指令的执行结果：" + cmdStatus + "，错误信息（如果有的话）：" + errMsg);
+        isDone = true;
+        // 更新指令执行记录表
         cmdExecModel.setCmdStatus(cmdStatus.getCode());
         cmdExecModel.setErrmsg(errMsg);
-
         //告诉checkservie我知道结果了
-        cmdResultCheckService.onChecked(cmdExecModel);
-
-
-
-        //TODO 更新指令执行记录表
-        //cmdDispatcherService.onCmdResult(cmdExecModel);
+        SpringUtils.getBean(CmdResultCheckService.class).onChecked(cmdExecModel);
     }
 
 
     /**
      * 单条指令执行结果检查
-     *  (收到设备发来的消息时，根据上报消息中的数据进行比对，来判断指令是否已执行成功)
+     * (收到设备发来的消息时，根据上报消息中的数据进行比对，来判断指令是否已执行成功)
+     *
      * @param jobjMsg
      */
-    public void check(IotDevice iotDevice, JSONObject jobjMsg){
-
+    public void check(IotDevice iotDevice, JSONObject jobjMsg) {
 
 
     }

src/main/java/com/yunfeiyun/agmp/iots/service/checker/EzvizCmdResultChecker.java

@@ -3,43 +3,32 @@ package com.yunfeiyun.agmp.iots.service.checker;
 import com.alibaba.fastjson2.JSONObject;
 import com.yunfeiyun.agmp.iot.common.constant.cmd.CmdStatus;
 import com.yunfeiyun.agmp.iot.common.domain.IotDevice;
-import com.yunfeiyun.agmp.iot.common.constant.devicetype.ServiceNameConst;
-import com.yunfeiyun.agmp.iots.core.cmd.core.CmdDispatcherService;
 import com.yunfeiyun.agmp.iots.core.cmd.model.CmdExecModel;
-import com.yunfeiyun.agmp.iots.service.IIotCmdlogService;
 import lombok.extern.slf4j.Slf4j;
 
-import javax.annotation.Resource;
 
 @Slf4j
 public class EzvizCmdResultChecker extends CmdResultChecker {
-    public EzvizCmdResultChecker(CmdExecModel cmdExecModel, CmdResultCheckService cmdResultCheckService, CmdDispatcherService cmdDispatcherService) {
-        super(cmdExecModel, cmdResultCheckService, cmdDispatcherService);
+    public EzvizCmdResultChecker(CmdExecModel cmdExecModel) {
+        super(cmdExecModel);
     }
 
-    @Resource
-    private IIotCmdlogService iIotCmdlogService;
-
-    private static final String SERVICE_NAME = ServiceNameConst.SERVICE_Ht_SF;
 
     @Override
     public void reqData() {
-        //云飞测报灯不需要发查询指令(发了“修改配置”指令后，设备会稍后返回一条“数据上报”)
+
     }
 
     /**
-     * 宏泰水肥的单条指令执行结果判断
      * (收到设备发来的消息时，根据上报消息中的数据进行比对)
      */
     @Override
     public void check(IotDevice iotDevice, JSONObject jobjMsg) {
         log.debug("萤石云平台设备 指令执行结果检查");
-        //对于config指令，支持一次设置一个或多个设置项，要判断上报的设置数据中，所有要设置的设置项的值，都已相同，才认为是设置成功
-        CmdExecModel cmdExecModel = getCmdExecModel();
     }
 
     @Override
-    public void onResult(CmdStatus cmdStatus, String errMsg){
+    public void onResult(CmdStatus cmdStatus, String errMsg) {
         super.onResult(cmdStatus, errMsg);
     }
 }

src/main/java/com/yunfeiyun/agmp/iots/service/checker/YfBzyCmdResultChecker.java

@@ -17,18 +17,11 @@ import java.util.Set;
 @Slf4j
 public class YfBzyCmdResultChecker extends CmdResultChecker {
 
-    private final IIotCmdlogService iIotCmdlogService = SpringUtils.getBean("iotCmdlogServiceImpl");
 
-    public YfBzyCmdResultChecker(CmdExecModel cmdExecModel, CmdResultCheckService cmdResultCheckService, CmdDispatcherService cmdDispatcherService) {
-        super(cmdExecModel, cmdResultCheckService, cmdDispatcherService);
+    public YfBzyCmdResultChecker(CmdExecModel cmdExecModel) {
+        super(cmdExecModel);
     }
 
-    @Override
-    public void reqData() {
-        //云飞孢子仪不需要发查询指令(发了“修改配置”指令后，设备会稍后返回一条“数据上报”)
-    }
-
-
     /**
      * 孢子仪的单条指令执行结果判断
      * (收到设备发来的消息时，根据上报消息中的数据进行比对)
@@ -94,7 +87,7 @@ public class YfBzyCmdResultChecker extends CmdResultChecker {
                 cmdModel.setClogValidresult(clogValidresult);
                 cmdModel.setClogDesc(clogDesc);
 
-                iIotCmdlogService.insertSuccessCmdlog(cmdModel);
+                SpringUtils.getBean(IIotCmdlogService.class).insertSuccessCmdlog(cmdModel);
             } else {
                 log.info("TODO 其它指令：" + cmd.getFunc());
             }

src/main/java/com/yunfeiyun/agmp/iots/service/checker/YfCbdCmdResultChecker.java

@@ -17,18 +17,11 @@ import java.util.Set;
 @Slf4j
 public class YfCbdCmdResultChecker extends CmdResultChecker {
 
-    private final IIotCmdlogService iIotCmdlogService = SpringUtils.getBean("iotCmdlogServiceImpl");
 
-    public YfCbdCmdResultChecker(CmdExecModel cmdExecModel, CmdResultCheckService cmdResultCheckService, CmdDispatcherService cmdDispatcherService) {
-        super(cmdExecModel, cmdResultCheckService, cmdDispatcherService);
+    public YfCbdCmdResultChecker(CmdExecModel cmdExecModel) {
+        super(cmdExecModel);
     }
 
-    @Override
-    public void reqData() {
-        //云飞测报灯不需要发查询指令(发了“修改配置”指令后，设备会稍后返回一条“数据上报”)
-    }
-
-
     /**
      * 测报灯的单条指令执行结果判断
      * (收到设备发来的消息时，根据上报消息中的数据进行比对)
@@ -36,7 +29,6 @@ public class YfCbdCmdResultChecker extends CmdResultChecker {
     @Override
     public void check(IotDevice iotDevice, JSONObject jobjMsg) {
 
-
         log.debug("云飞测报灯 指令执行结果检查");
         //对于config指令，支持一次设置一个或多个设置项，要判断上报的设置数据中，所有要设置的设置项的值，都已相同，才认为是设置成功
 
@@ -94,7 +86,7 @@ public class YfCbdCmdResultChecker extends CmdResultChecker {
                 cmdModel.setClogValidresult(clogValidresult);
                 cmdModel.setClogDesc(clogDesc);
 
-                iIotCmdlogService.insertSuccessCmdlog(cmdModel);
+                SpringUtils.getBean(IIotCmdlogService.class).insertSuccessCmdlog(cmdModel);
             } else {
                 log.debug("TODO 其它指令：" + cmd.getFunc());
             }

src/main/java/com/yunfeiyun/agmp/iots/service/impl/IotDeviceServiceImpl.java

@@ -319,6 +319,11 @@ public class IotDeviceServiceImpl implements IIotDeviceService {
         iotDeviceMapper.updateIotDeviceBatch(iotDeviceList);
     }
 
+    @Override
+    public List<String> getDeviceCodesByConectionId(String connectionId) {
+        return iotDeviceMapper.getDeviceCodesByConectionId(connectionId);
+    }
+
 
     /**
      * 是否是属于需要忽略状态的设备

src/main/java/com/yunfeiyun/agmp/iots/service/impl/WarnService.java

@@ -146,7 +146,7 @@ public class WarnService {
      * 每个整点执行一次 预警检查
      */
     //@Async
-    @Scheduled(cron = "0 0 * * * ?")
+    //@Scheduled(cron = "0 0 * * * ?")
     //@Scheduled(cron = "0 */1 * * * ?")  //调试期间，每分钟 执行一次
     private void jobCheck() {
 

src/main/java/com/yunfeiyun/agmp/iots/task/IotStatusService.java

@@ -68,7 +68,7 @@ public class IotStatusService {
         //validateDeviceType.add(IotDeviceDictConst.TYPE_YF_QXZ);//云飞气象站
         validateDeviceType.add(IotDeviceDictConst.TYPE_YF_SCD);// 云飞杀虫灯
         try{
-            selectSfStatusByAll();
+            //selectSfStatusByAll();
         }catch (Exception e){
             log.error("【设备检测】异常", e);
         }
@@ -78,7 +78,7 @@ public class IotStatusService {
     /**
      * 定期根据类型查设备最新设备数据，是否长时间不上报。，并进行重新订阅
      */
-    @Scheduled(cron = "0 0 */1 * * ?")
+    //@Scheduled(cron = "0 0 */1 * * ?")
     public void selectSfStatusByAll() throws MqttException {
         printMqttStatus();
         Iterator<String> iterator = validateDeviceType.iterator();

src/main/resources/mapper/BusinessCoreMapper.xml

@@ -8,10 +8,17 @@
     <!-- * 这个方法的定位就是：获取设备型号的信息，用于构建链接 *-->
     <select id="selectTosDevicetypeResVoList"
             resultType="com.yunfeiyun.agmp.iots.common.modal.IotDeviceconnResVo">
-        SELECT
-        *
-        from
-        IotDeviceconn
+            SELECT
+                ic.*,
+        it.devtypeName,
+        it.devtypeCode ,
+        ifd.firmName,
+        ifd.firmBid
+
+                from
+                IotDeviceconn ic
+        LEFT JOIN TosDevicetype it on ic.devtypeBid = it.devtypeBid
+        LEFT JOIN TosFirm ifd on ifd.firmBid=it.firmBid
 
     </select>
 

src/main/resources/mapper/IotCmdexecMapper.xml

@@ -132,7 +132,7 @@
         insert into IotCmdexec
         <trim prefix="(" suffix=")" suffixOverrides=",">
             ceBid,
-            cId,
+            tid,
             ctBid,
             devBid,
             ceGroupbid,

src/main/resources/mapper/IotDeviceMapper.xml

@@ -509,6 +509,9 @@
         and d.devDelstatus='0'
         group by d.devBid
     </select>
+    <select id="getDeviceCodesByConectionId" resultType="java.lang.String">
+        select  devCode from IotDevice where devconnBid=#{connectionId} and devDelstatus='0'
+    </select>
 </mapper>