新增设备公共Controller,公共接口

src/main/java/com/yunfeiyun/agmp/iotm/common/service/IotDeviceBaseServiceImpl.java

@@ -1,259 +0,0 @@
-package com.yunfeiyun.agmp.iotm.common.service;
-
-import com.alibaba.fastjson2.JSONObject;
-import com.yunfeiyun.agmp.common.constant.ErrorCode;
-import com.yunfeiyun.agmp.common.exception.BizException;
-import com.yunfeiyun.agmp.iot.common.exception.IotBizException;
-import com.yunfeiyun.agmp.iotm.common.vo.reqVo.IotDeviceBaseCtlReqVo;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.aop.framework.AopContext;
-import org.springframework.stereotype.Component;
-import org.springframework.transaction.annotation.Transactional;
-
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.util.List;
-
-/**
- * @author 123
- */
-@Component
-@Slf4j
-public abstract class IotDeviceBaseServiceImpl implements IotDeviceBaseService {
-    /**
-     * 此公共方法要求调用的方法的入参数量必须小于等于1
-     * */
-    @Override
-    public <T> String ctl(IotDeviceBaseCtlReqVo iotDeviceBaseCtlReqVo)  {
-        // 获取将要执行的方法
-        String methodName = iotDeviceBaseCtlReqVo.getCtlType();
-        // 获取类下所有的方法
-        Method[] methods = this.getClass().getDeclaredMethods();
-        Method method = null;
-        T param = null;
-        // 根据methodName通过反射获取对应方法,并对参数进行预处理
-        for(Method item : methods){
-            // 判断方法名称与参数数量
-            if(!item.getName().equals(methodName)||item.getParameterCount()>1){
-                continue;
-            }
-            method = item;
-            // 获取方法的参数类型
-            Class<?>[] paramClass = item.getParameterTypes();
-            // 方法若是无参，则无需进行转化
-            if(paramClass.length == 1){
-                Object reqParam = iotDeviceBaseCtlReqVo.getParams();
-                if(reqParam instanceof String && !paramClass[0].equals(String.class)){
-                    // 如果参数类型是String,且接口入参是非String类,则将字符串参数转化为对应类型
-                    param = (T) JSONObject.parseObject((String) reqParam,paramClass[0]);
-                }else if(reqParam instanceof JSONObject && !paramClass[0].equals(JSONObject.class)){
-                    // 如果参数类型是JSONObject,且接口入参是非JSONObject类,则将JSONObject参数转化为对应类型
-                    param = (T) ((JSONObject) reqParam).to(paramClass[0]);
-                }else {
-                    // 无需转化，则直接赋值
-                    param = (T) reqParam;
-                }
-            }
-            break;
-        }
-        try {
-            if("close".equals(methodName)&&null == method){
-                log.debug("设备未实现关闭方法,无需手动关闭,不再继续执行");
-                return null;
-            }else if(null == method){
-                throw new BizException(ErrorCode.SYSTEM_ERROR.getCode(),"设备未实现操作方法");
-            }
-            Object current;
-            if(method.getAnnotation(Transactional.class) != null){
-                current = AopContext.currentProxy();
-            }else {
-                current = this;
-            }
-            return (String) method.invoke(current,param);
-        }catch (InvocationTargetException e){
-            Throwable throwable = e.getTargetException();
-            if(throwable instanceof IotBizException){
-                throw ( IotBizException ) throwable;
-            }
-            if(throwable instanceof BizException){
-                throw ( BizException ) throwable;
-            }
-            log.error("",e);
-            throw new BizException(ErrorCode.SYSTEM_ERROR.getCode(),"设备控制失败,错误原因未知");
-        }catch (IllegalAccessException e){
-            log.error("",e);
-            throw new BizException(ErrorCode.SYSTEM_ERROR.getCode(),"设备未实现操作方法");
-        }
-    }
-    @Override
-    public <T> T reset(String devBid){
-        Method method = null;
-        try {
-            method = this.getClass().getDeclaredMethod("reset",String.class);
-        } catch (NoSuchMethodException e) {
-            throw new IotBizException(ErrorCode.INVALID_PARAMETER.getCode(),"设备未实现简单重置方法");
-        }
-        try {
-            return (T) method.invoke(AopContext.currentProxy(),devBid);
-        }catch (InvocationTargetException e){
-            Throwable throwable = e.getTargetException();
-            if(throwable instanceof IotBizException){
-                throw ( IotBizException ) throwable;
-            }
-            if(throwable instanceof BizException){
-                throw ( BizException ) throwable;
-            }
-            log.error("",e);
-            throw new BizException(ErrorCode.SYSTEM_ERROR.getCode(),"设备重置方法执行失败,错误原因未知");
-        }catch (IllegalAccessException e){
-            log.error("",e);
-            throw new BizException(ErrorCode.SYSTEM_ERROR.getCode(),"设备未实现简单重置方法");
-        }
-    }
-    @Override
-    public <T> List<T> list(Object... listParams) {
-        // 获取执行的指令
-        Class<?>[] paramClasses = new Class[listParams.length];
-        for(int i = 0;i<listParams.length;i++){
-            paramClasses[i] = listParams[i].getClass();
-        }
-        Method method = null;
-        try {
-            method = this.getClass().getDeclaredMethod("list",paramClasses);
-        } catch (NoSuchMethodException e) {
-            throw new IotBizException(ErrorCode.INVALID_PARAMETER.getCode(),"设备未实现详情方法");
-        }
-        try {
-            return (List<T>) method.invoke(AopContext.currentProxy(),listParams);
-        }catch (InvocationTargetException e){
-            Throwable throwable = e.getTargetException();
-            if(throwable instanceof IotBizException){
-                throw ( IotBizException ) throwable;
-            }
-            if(throwable instanceof BizException){
-                throw ( BizException ) throwable;
-            }
-            log.error("",e);
-            throw new BizException(ErrorCode.SYSTEM_ERROR.getCode(),"设备控制失败,错误原因未知");
-        }catch (IllegalAccessException e){
-            log.error("",e);
-            throw new BizException(ErrorCode.SYSTEM_ERROR.getCode(),"设备未实现操作方法");
-        }
-    }
-    @Override
-    public <T> T info(Object... infoParams) {
-        Class<?>[] paramClasses = new Class[infoParams.length];
-        for(int i = 0;i<infoParams.length;i++){
-            paramClasses[i] = infoParams[i].getClass();
-        }
-        Method method = null;
-        try {
-            method = this.getClass().getDeclaredMethod("info",paramClasses);
-        } catch (NoSuchMethodException e) {
-            throw new IotBizException(ErrorCode.INVALID_PARAMETER.getCode(),"设备未实现详情查询方法");
-        }
-        try {
-            return (T) method.invoke(AopContext.currentProxy(),infoParams);
-        }catch (InvocationTargetException e){
-            Throwable throwable = e.getTargetException();
-            if(throwable instanceof IotBizException){
-                throw ( IotBizException ) throwable;
-            }
-            if(throwable instanceof BizException){
-                throw ( BizException ) throwable;
-            }
-            log.error("",e);
-            throw new BizException(ErrorCode.SYSTEM_ERROR.getCode(),"设备详情查询失败,错误原因未知");
-        }catch (IllegalAccessException e){
-            log.error("",e);
-            throw new BizException(ErrorCode.SYSTEM_ERROR.getCode(),"设备未实现详情查询方法");
-        }
-    }
-    @Override
-    public <T> T edit(Object... infoParams){
-        Class<?>[] paramClasses = new Class[infoParams.length];
-        for(int i = 0;i<infoParams.length;i++){
-            paramClasses[i] = infoParams[i].getClass();
-        }
-        Method method = null;
-        try {
-            method = this.getClass().getDeclaredMethod("edit",paramClasses);
-        } catch (NoSuchMethodException e) {
-            throw new IotBizException(ErrorCode.INVALID_PARAMETER.getCode(),"设备未实现基础信息编辑方法");
-        }
-        try {
-            return (T) method.invoke(AopContext.currentProxy(),infoParams);
-        }catch (InvocationTargetException e){
-            Throwable throwable = e.getTargetException();
-            if(throwable instanceof IotBizException){
-                throw ( IotBizException ) throwable;
-            }
-            if(throwable instanceof BizException){
-                throw ( BizException ) throwable;
-            }
-            log.error("",e);
-            throw new BizException(ErrorCode.SYSTEM_ERROR.getCode(),"设备基础信息编辑失败,错误原因未知");
-        }catch (IllegalAccessException e){
-            log.error("",e);
-            throw new BizException(ErrorCode.SYSTEM_ERROR.getCode(),"设备未实现基础信息编辑方法");
-        }
-    }
-    @Override
-    public <T> T editConfig(Object... infoParams){
-        Class<?>[] paramClasses = new Class[infoParams.length];
-        for(int i = 0;i<infoParams.length;i++){
-            paramClasses[i] = infoParams[i].getClass();
-        }
-        Method method = null;
-        try {
-            method = this.getClass().getDeclaredMethod("editConfig",paramClasses);
-        } catch (NoSuchMethodException e) {
-            throw new IotBizException(ErrorCode.INVALID_PARAMETER.getCode(),"设备未实现配置信息编辑方法");
-        }
-        try {
-            return (T) method.invoke(AopContext.currentProxy(),infoParams);
-        }catch (InvocationTargetException e){
-            Throwable throwable = e.getTargetException();
-            if(throwable instanceof IotBizException){
-                throw ( IotBizException ) throwable;
-            }
-            if(throwable instanceof BizException){
-                throw ( BizException ) throwable;
-            }
-            log.error("",e);
-            throw new BizException(ErrorCode.SYSTEM_ERROR.getCode(),"设备配置信息编辑失败,错误原因未知");
-        }catch (IllegalAccessException e){
-            log.error("",e);
-            throw new BizException(ErrorCode.SYSTEM_ERROR.getCode(),"设备未实现配置信息编辑方法");
-        }
-    }
-    @Override
-    public <T> T delete(Object... infoParams){
-        Class<?>[] paramClasses = new Class[infoParams.length];
-        for(int i = 0;i<infoParams.length;i++){
-            paramClasses[i] = infoParams[i].getClass();
-        }
-        Method method = null;
-        try {
-            method = this.getClass().getDeclaredMethod("delete",paramClasses);
-        } catch (NoSuchMethodException e) {
-            throw new IotBizException(ErrorCode.INVALID_PARAMETER.getCode(),"设备未实现编辑方法");
-        }
-        try {
-            return (T) method.invoke(AopContext.currentProxy(),infoParams);
-        }catch (InvocationTargetException e){
-            Throwable throwable = e.getTargetException();
-            if(throwable instanceof IotBizException){
-                throw ( IotBizException ) throwable;
-            }
-            if(throwable instanceof BizException){
-                throw ( BizException ) throwable;
-            }
-            log.error("",e);
-            throw new BizException(ErrorCode.SYSTEM_ERROR.getCode(),"设备详情查询失败,错误原因未知");
-        }catch (IllegalAccessException e){
-            log.error("",e);
-            throw new BizException(ErrorCode.SYSTEM_ERROR.getCode(),"设备未实现详情查询方法");
-        }
-    }
-}

src/main/java/com/yunfeiyun/agmp/iotm/common/vo/reqVo/IotDeviceBaseCtlReqVo.java

@@ -1,14 +1,25 @@
-package com.yunfeiyun.agmp.iotm.common.vo.reqVo;
+package com.yunfeiyun.agmp.iotm.device.common.domin;
 
 import com.alibaba.fastjson2.JSONObject;
+import com.yunfeiyun.agmp.iot.common.domain.IotDevice;
+import lombok.Data;
 import lombok.NoArgsConstructor;
 
 /**
  * 物联网设备实现接口通用参数
  * */
+@Data
 @NoArgsConstructor
 public class IotDeviceBaseCtlReqVo {
     /**
+     * 设备标识
+     * */
+    private String devBid;
+    /**
+     * 设备基础数据
+     * */
+    private IotDevice iotDevice;
+    /**
      * 操作类型-》对应所有的DeviceBaseService接口实现类中的所有的方法名称
      * */
     private String ctlType;
@@ -21,7 +32,6 @@ public class IotDeviceBaseCtlReqVo {
     public IotDeviceBaseCtlReqVo(String ctlType, Object param){
         this.ctlType = ctlType;
         this.params = param;
-
     }
     public String getCtlType(){
         return this.ctlType;
@@ -33,4 +43,6 @@ public class IotDeviceBaseCtlReqVo {
         return this.params;
     }
 
+
+
 }

src/main/java/com/yunfeiyun/agmp/iotm/device/common/domin/IotDeviceBaseListReqVo.java

@@ -0,0 +1,11 @@
+package com.yunfeiyun.agmp.iotm.device.common.domin;
+
+import com.alibaba.fastjson2.JSONObject;
+import com.yunfeiyun.agmp.iot.common.domain.IotDevice;
+import lombok.Data;
+
+@Data
+public class IotDeviceBaseListReqVo extends IotDevice {
+    private String landId;
+    private String blockId;
+}

src/main/java/com/yunfeiyun/agmp/iotm/common/service/IotDeviceBaseService.java

@@ -1,18 +1,25 @@
-package com.yunfeiyun.agmp.iotm.common.service;
+package com.yunfeiyun.agmp.iotm.device.common.service;
 
-import com.yunfeiyun.agmp.iotm.common.vo.reqVo.IotDeviceBaseCtlReqVo;
+import com.yunfeiyun.agmp.iotm.device.common.domin.IotDeviceBaseCtlReqVo;
 
 import java.util.List;
 
 /**
  * 物联网管理平台设备公共基础接口
+ * <p>
  * 如何对接一个新设备：
- * 所有对接的设备均需要创建一个XXXService接口并继承该公共接口，且对应接口的实现类需要继承IotDeviceBaseServiceImpl,
+ * <p>
+ * 所有对接的设备均需要创建一个XXXService接口并继承该公共接口，且对应接口的实现类需要继承IotDeviceBaseServiceImpl
+ * <p>
  * 在@Service注解中,传入value参数，值为ServiceNameConstant中对应的常量名
+ * <p>
  * 在IotDeviceBaseServiceImpl中已经对以下公共接口进行抽象实现。具体设备的实现类无须重写
+ * <p>
  * 对接设备时，如设备需要实现公共调用，则在实现设备控制，数据操作等接口时，按照以下公共接口进行实现
- * 可参考 IotJsyStQfService
- *
+ * <p>
+ * 可参考 IotEzvizMonitor
+ * <p>
+ * 注意，由于IotDeviceService中已经注入了IotDeviceBaseService，在IotDeviceBaseService相关实现类中不要再注入IotDeviceService,防止循环依赖，对应的数据库操作可以通过IotDeviceMapper实现
  * @author 123*/
 public interface IotDeviceBaseService {
     /**

src/main/java/com/yunfeiyun/agmp/iotm/device/common/service/IotDeviceCommonService.java

@@ -0,0 +1,16 @@
+package com.yunfeiyun.agmp.iotm.device.common.service;
+
+import com.yunfeiyun.agmp.iotm.device.common.domin.IotDeviceBaseCtlReqVo;
+import com.yunfeiyun.agmp.iotm.device.common.domin.IotDeviceBaseListReqVo;
+import org.apache.poi.ss.formula.functions.T;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+public interface IotDeviceCommonService {
+    public <T> List<T> list(IotDeviceBaseListReqVo iotDeviceBaseListReqVo);
+
+    public <T> String ctl(IotDeviceBaseCtlReqVo iotDeviceBaseCtlReqVo);
+
+    public <T> T info(String devBid);
+}

src/main/java/com/yunfeiyun/agmp/iotm/device/common/service/impl/IotDeviceBaseServiceImpl.java

@@ -0,0 +1,281 @@
+package com.yunfeiyun.agmp.iotm.device.common.service.impl;
+
+import com.alibaba.fastjson2.JSONObject;
+import com.yunfeiyun.agmp.common.constant.ErrorCode;
+import com.yunfeiyun.agmp.common.exception.BizException;
+import com.yunfeiyun.agmp.iot.common.domain.IotDevice;
+import com.yunfeiyun.agmp.iot.common.exception.IotBizException;
+import com.yunfeiyun.agmp.iotm.device.common.domin.IotDeviceBaseCtlReqVo;
+import com.yunfeiyun.agmp.iotm.device.common.service.IotDeviceBaseService;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.aop.framework.AopContext;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.List;
+
+/**
+ * @author 123
+ */
+@Component
+@Slf4j
+public abstract class IotDeviceBaseServiceImpl implements IotDeviceBaseService {
+    /**
+     * 此公共方法要求调用的方法的入参数量必须小于等于1
+     */
+    @Override
+    public <T> String ctl(IotDeviceBaseCtlReqVo iotDeviceBaseCtlReqVo) {
+        // 获取将要执行的方法
+        String methodName = iotDeviceBaseCtlReqVo.getCtlType();
+        // 获取类下所有的方法
+        Method[] methods = this.getClass().getDeclaredMethods();
+        Method method = null;
+        T param = null;
+        // 根据methodName通过反射获取对应方法,并对参数进行预处理
+        for (Method item : methods) {
+            // 判断方法名称与参数数量
+            if (!item.getName().equals(methodName) || item.getParameterCount() > 1) {
+                continue;
+            }
+            method = item;
+            // 获取方法的参数类型
+            Class<?>[] paramClass = item.getParameterTypes();
+            // 方法若是无参，则无需进行转化
+            if (paramClass.length == 1) {
+                Object reqParam = iotDeviceBaseCtlReqVo.getParams();
+                if (reqParam instanceof String && !paramClass[0].equals(String.class)) {
+                    // 如果参数类型是String,且接口入参是非String类,则将字符串参数转化为对应类型
+                    param = (T) JSONObject.parseObject((String) reqParam, paramClass[0]);
+                    setIotDeviceInParams(iotDeviceBaseCtlReqVo.getIotDevice(), param);
+                } else if (reqParam instanceof JSONObject && !paramClass[0].equals(JSONObject.class)) {
+                    // 如果参数类型是JSONObject,且接口入参是非JSONObject类,则将JSONObject参数转化为对应类型
+                    param = (T) ((JSONObject) reqParam).to(paramClass[0]);
+                    setIotDeviceInParams(iotDeviceBaseCtlReqVo.getIotDevice(), param);
+                } else if (reqParam instanceof JSONObject) {
+                    ((JSONObject) reqParam).put("IotDevice", iotDeviceBaseCtlReqVo.getIotDevice());
+                    param = (T) reqParam;
+                } else {
+                    // 无需转化，则直接赋值
+                    param = (T) reqParam;
+                }
+            }
+            break;
+        }
+        try {
+            if ("close".equals(methodName) && null == method) {
+                log.debug("设备未实现关闭方法,无需手动关闭,不再继续执行");
+                return null;
+            } else if (null == method) {
+                throw new BizException(ErrorCode.SYSTEM_ERROR.getCode(), "设备未实现操作方法");
+            }
+            Object current;
+            if (method.getAnnotation(Transactional.class) != null) {
+                current = AopContext.currentProxy();
+            } else {
+                current = this;
+            }
+            return (String) method.invoke(current, param);
+        } catch (InvocationTargetException e) {
+            Throwable throwable = e.getTargetException();
+            if (throwable instanceof IotBizException) {
+                throw (IotBizException) throwable;
+            }
+            if (throwable instanceof BizException) {
+                throw (BizException) throwable;
+            }
+            log.error("", e);
+            throw new BizException(ErrorCode.SYSTEM_ERROR.getCode(), "设备控制失败,错误原因未知");
+        } catch (IllegalAccessException e) {
+            log.error("", e);
+            throw new BizException(ErrorCode.SYSTEM_ERROR.getCode(), "设备未实现操作方法");
+        }
+    }
+
+    @Override
+    public <T> T reset(String devBid) {
+        Method method = null;
+        try {
+            method = this.getClass().getDeclaredMethod("reset", String.class);
+        } catch (NoSuchMethodException e) {
+            throw new IotBizException(ErrorCode.INVALID_PARAMETER.getCode(), "设备未实现简单重置方法");
+        }
+        try {
+            return (T) method.invoke(AopContext.currentProxy(), devBid);
+        } catch (InvocationTargetException e) {
+            Throwable throwable = e.getTargetException();
+            if (throwable instanceof IotBizException) {
+                throw (IotBizException) throwable;
+            }
+            if (throwable instanceof BizException) {
+                throw (BizException) throwable;
+            }
+            log.error("", e);
+            throw new BizException(ErrorCode.SYSTEM_ERROR.getCode(), "设备重置方法执行失败,错误原因未知");
+        } catch (IllegalAccessException e) {
+            log.error("", e);
+            throw new BizException(ErrorCode.SYSTEM_ERROR.getCode(), "设备未实现简单重置方法");
+        }
+    }
+
+    @Override
+    public <T> List<T> list(Object... listParams) {
+        // 获取执行的指令
+        Class<?>[] paramClasses = new Class[listParams.length];
+        for (int i = 0; i < listParams.length; i++) {
+            paramClasses[i] = listParams[i].getClass();
+        }
+        Method method = null;
+        try {
+            method = this.getClass().getDeclaredMethod("list", paramClasses);
+        } catch (NoSuchMethodException e) {
+            throw new IotBizException(ErrorCode.INVALID_PARAMETER.getCode(), "设备未实现详情方法");
+        }
+        try {
+            return (List<T>) method.invoke(AopContext.currentProxy(), listParams);
+        } catch (InvocationTargetException e) {
+            Throwable throwable = e.getTargetException();
+            if (throwable instanceof IotBizException) {
+                throw (IotBizException) throwable;
+            }
+            if (throwable instanceof BizException) {
+                throw (BizException) throwable;
+            }
+            log.error("", e);
+            throw new BizException(ErrorCode.SYSTEM_ERROR.getCode(), "设备控制失败,错误原因未知");
+        } catch (IllegalAccessException e) {
+            log.error("", e);
+            throw new BizException(ErrorCode.SYSTEM_ERROR.getCode(), "设备未实现操作方法");
+        }
+    }
+
+    @Override
+    public <T> T info(Object... infoParams) {
+        Class<?>[] paramClasses = new Class[infoParams.length];
+        for (int i = 0; i < infoParams.length; i++) {
+            paramClasses[i] = infoParams[i].getClass();
+        }
+        Method method = null;
+        try {
+            method = this.getClass().getDeclaredMethod("info", paramClasses);
+        } catch (NoSuchMethodException e) {
+            throw new IotBizException(ErrorCode.INVALID_PARAMETER.getCode(), "设备未实现详情查询方法");
+        }
+        try {
+            return (T) method.invoke(AopContext.currentProxy(), infoParams);
+        } catch (InvocationTargetException e) {
+            Throwable throwable = e.getTargetException();
+            if (throwable instanceof IotBizException) {
+                throw (IotBizException) throwable;
+            }
+            if (throwable instanceof BizException) {
+                throw (BizException) throwable;
+            }
+            log.error("", e);
+            throw new BizException(ErrorCode.SYSTEM_ERROR.getCode(), "设备详情查询失败,错误原因未知");
+        } catch (IllegalAccessException e) {
+            log.error("", e);
+            throw new BizException(ErrorCode.SYSTEM_ERROR.getCode(), "设备未实现详情查询方法");
+        }
+    }
+
+    @Override
+    public <T> T edit(Object... infoParams) {
+        Class<?>[] paramClasses = new Class[infoParams.length];
+        for (int i = 0; i < infoParams.length; i++) {
+            paramClasses[i] = infoParams[i].getClass();
+        }
+        Method method = null;
+        try {
+            method = this.getClass().getDeclaredMethod("edit", paramClasses);
+        } catch (NoSuchMethodException e) {
+            throw new IotBizException(ErrorCode.INVALID_PARAMETER.getCode(), "设备未实现基础信息编辑方法");
+        }
+        try {
+            return (T) method.invoke(AopContext.currentProxy(), infoParams);
+        } catch (InvocationTargetException e) {
+            Throwable throwable = e.getTargetException();
+            if (throwable instanceof IotBizException) {
+                throw (IotBizException) throwable;
+            }
+            if (throwable instanceof BizException) {
+                throw (BizException) throwable;
+            }
+            log.error("", e);
+            throw new BizException(ErrorCode.SYSTEM_ERROR.getCode(), "设备基础信息编辑失败,错误原因未知");
+        } catch (IllegalAccessException e) {
+            log.error("", e);
+            throw new BizException(ErrorCode.SYSTEM_ERROR.getCode(), "设备未实现基础信息编辑方法");
+        }
+    }
+
+    @Override
+    public <T> T editConfig(Object... infoParams) {
+        Class<?>[] paramClasses = new Class[infoParams.length];
+        for (int i = 0; i < infoParams.length; i++) {
+            paramClasses[i] = infoParams[i].getClass();
+        }
+        Method method = null;
+        try {
+            method = this.getClass().getDeclaredMethod("editConfig", paramClasses);
+        } catch (NoSuchMethodException e) {
+            throw new IotBizException(ErrorCode.INVALID_PARAMETER.getCode(), "设备未实现配置信息编辑方法");
+        }
+        try {
+            return (T) method.invoke(AopContext.currentProxy(), infoParams);
+        } catch (InvocationTargetException e) {
+            Throwable throwable = e.getTargetException();
+            if (throwable instanceof IotBizException) {
+                throw (IotBizException) throwable;
+            }
+            if (throwable instanceof BizException) {
+                throw (BizException) throwable;
+            }
+            log.error("", e);
+            throw new BizException(ErrorCode.SYSTEM_ERROR.getCode(), "设备配置信息编辑失败,错误原因未知");
+        } catch (IllegalAccessException e) {
+            log.error("", e);
+            throw new BizException(ErrorCode.SYSTEM_ERROR.getCode(), "设备未实现配置信息编辑方法");
+        }
+    }
+
+    @Override
+    public <T> T delete(Object... infoParams) {
+        Class<?>[] paramClasses = new Class[infoParams.length];
+        for (int i = 0; i < infoParams.length; i++) {
+            paramClasses[i] = infoParams[i].getClass();
+        }
+        Method method = null;
+        try {
+            method = this.getClass().getDeclaredMethod("delete", paramClasses);
+        } catch (NoSuchMethodException e) {
+            throw new IotBizException(ErrorCode.INVALID_PARAMETER.getCode(), "设备未实现编辑方法");
+        }
+        try {
+            return (T) method.invoke(AopContext.currentProxy(), infoParams);
+        } catch (InvocationTargetException e) {
+            Throwable throwable = e.getTargetException();
+            if (throwable instanceof IotBizException) {
+                throw (IotBizException) throwable;
+            }
+            if (throwable instanceof BizException) {
+                throw (BizException) throwable;
+            }
+            log.error("", e);
+            throw new BizException(ErrorCode.SYSTEM_ERROR.getCode(), "设备详情查询失败,错误原因未知");
+        } catch (IllegalAccessException e) {
+            log.error("", e);
+            throw new BizException(ErrorCode.SYSTEM_ERROR.getCode(), "设备未实现详情查询方法");
+        }
+    }
+
+    private void setIotDeviceInParams(IotDevice iotDevice, Object param) {
+        try {
+            Method method = param.getClass().getDeclaredMethod("setIotDevice", IotDevice.class);
+            method.invoke(param, iotDevice);
+        } catch (Exception e) {
+            log.debug("通用控制接口自动写入IotDevice失败,失败原因:", e);
+        }
+    }
+}

src/main/java/com/yunfeiyun/agmp/iotm/device/common/service/impl/IotDeviceCommonServiceImpl.java

@@ -0,0 +1,65 @@
+package com.yunfeiyun.agmp.iotm.device.common.service.impl;
+
+import com.baomidou.mybatisplus.core.toolkit.ObjectUtils;
+import com.yunfeiyun.agmp.common.constant.ErrorCode;
+import com.yunfeiyun.agmp.common.exception.BizException;
+import com.yunfeiyun.agmp.common.utils.StringUtils;
+import com.yunfeiyun.agmp.iot.common.domain.IotDevice;
+import com.yunfeiyun.agmp.iot.common.exception.IotBizException;
+import com.yunfeiyun.agmp.iot.common.service.TypeCacheService;
+import com.yunfeiyun.agmp.iotm.device.common.domin.IotDeviceBaseCtlReqVo;
+import com.yunfeiyun.agmp.iotm.device.common.domin.IotDeviceBaseListReqVo;
+import com.yunfeiyun.agmp.iotm.device.common.service.IotDeviceBaseService;
+import com.yunfeiyun.agmp.iotm.device.common.service.IotDeviceCommonService;
+import com.yunfeiyun.agmp.iotm.web.mapper.IotDeviceMapper;
+import org.springframework.stereotype.Service;
+
+import javax.annotation.Resource;
+import java.util.List;
+import java.util.Map;
+
+@Service
+public class IotDeviceCommonServiceImpl implements IotDeviceCommonService {
+    @Resource
+    private Map<String, IotDeviceBaseService> iotDeviceBaseServiceMap;
+    @Resource
+    private TypeCacheService typeCacheService;
+    @Resource
+    private IotDeviceMapper iotDeviceMapper;
+    @Override
+    public <T> List<T> list(IotDeviceBaseListReqVo iotDeviceBaseListReqVo) {
+        if(StringUtils.isEmpty(iotDeviceBaseListReqVo.getDevtypeBid())){
+            throw new IotBizException(ErrorCode.INVALID_PARAMETER.getCode(),"设备类型为空");
+        }
+        IotDeviceBaseService iotDeviceBaseService = iotDeviceBaseServiceMap.get(typeCacheService.getServiceNameByDevTypeBid(iotDeviceBaseListReqVo.getDevtypeBid()));
+        return iotDeviceBaseService.list(iotDeviceBaseListReqVo);
+    }
+
+    @Override
+    public <T> T info(String devBid) {
+        if(StringUtils.isEmpty(devBid)){
+            throw new IotBizException(ErrorCode.INVALID_PARAMETER.getCode(),"设备标识为空");
+        }
+        IotDevice iotDevice = iotDeviceMapper.selectIotDeviceByDevBid(devBid);
+        if(ObjectUtils.isNull(iotDevice)){
+            throw new IotBizException(ErrorCode.INVALID_PARAMETER.getCode(),"未知设备");
+        }
+        IotDeviceBaseService iotDeviceBaseService = iotDeviceBaseServiceMap.get(typeCacheService.getServiceNameByDevTypeBid(iotDevice.getDevtypeBid()));
+        return iotDeviceBaseService.info(iotDevice);
+    }
+
+    @Override
+    public String ctl(IotDeviceBaseCtlReqVo iotDeviceBaseCtlReqVo) {
+        if(StringUtils.isEmpty(iotDeviceBaseCtlReqVo.getDevBid())){
+            throw new IotBizException(ErrorCode.INVALID_PARAMETER.getCode(),"设备标识为空");
+        }
+        IotDevice iotDevice = iotDeviceMapper.selectIotDeviceByDevBid(iotDeviceBaseCtlReqVo.getDevBid());
+        if(ObjectUtils.isNull(iotDevice)){
+            throw new IotBizException(ErrorCode.INVALID_PARAMETER.getCode(),"设备信息不存在");
+        }
+        iotDeviceBaseCtlReqVo.setIotDevice(iotDevice);
+        IotDeviceBaseService iotDeviceBaseService = iotDeviceBaseServiceMap.get(typeCacheService.getServiceNameByDevTypeBid(iotDevice.getDevtypeBid()));
+        return iotDeviceBaseService.ctl(iotDeviceBaseCtlReqVo);
+    }
+
+}

src/main/java/com/yunfeiyun/agmp/iotm/device/monitor/domin/IotEzvizDeviceAddressGetReqVo.java

@@ -0,0 +1,20 @@
+package com.yunfeiyun.agmp.iotm.device.monitor.domin;
+
+import com.yunfeiyun.agmp.iot.common.domain.IotDevice;
+import lombok.Data;
+
+@Data
+public class IotEzvizDeviceAddressGetReqVo extends IotDevice {
+
+    private Integer channelNo;
+    private Integer protocol;
+    private String code;
+    private Integer expireTime;
+    private String type;
+    private Integer quality;
+    private String startTime;
+    private String stopTime;
+    private Integer supportH265;
+    private String playbackSpeed;
+    private String gbchannel;
+}

src/main/java/com/yunfeiyun/agmp/iotm/device/monitor/domin/IotEzvizDeviceCaptureReqVo.java

@@ -0,0 +1,11 @@
+package com.yunfeiyun.agmp.iotm.device.monitor.domin;
+
+import com.yunfeiyun.agmp.iot.common.domain.IotDevice;
+import lombok.Data;
+
+@Data
+public class IotEzvizDeviceCaptureReqVo extends IotDevice {
+
+    private Integer channelNo;
+    private Integer quality;
+}

src/main/java/com/yunfeiyun/agmp/iotm/device/monitor/domin/IotEzvizDevicePtzReqVo.java

@@ -0,0 +1,12 @@
+package com.yunfeiyun.agmp.iotm.device.monitor.domin;
+
+import com.yunfeiyun.agmp.iot.common.domain.IotDevice;
+import lombok.Data;
+
+@Data
+public class IotEzvizDevicePtzReqVo extends IotDevice {
+
+    private Integer direction;
+    private Integer channelNo;
+    private Integer speed;
+}

src/main/java/com/yunfeiyun/agmp/iotm/device/monitor/domin/IotEzvizDeviceVideoReqVo.java

@@ -0,0 +1,16 @@
+package com.yunfeiyun.agmp.iotm.device.monitor.domin;
+
+import com.yunfeiyun.agmp.iot.common.domain.IotDevice;
+import lombok.Data;
+
+@Data
+public class IotEzvizDeviceVideoReqVo extends IotDevice {
+
+    private Integer channelNo;
+    private String startTime;
+    private String endTime;
+    private Integer recType;
+    private String version;
+    private Integer pageSize;
+
+}

src/main/java/com/yunfeiyun/agmp/iotm/device/monitor/service/IotEzvizMonitorService.java

@@ -0,0 +1,31 @@
+package com.yunfeiyun.agmp.iotm.device.monitor.service;
+
+import com.yunfeiyun.agmp.iot.common.domain.IotDevice;
+import com.yunfeiyun.agmp.iotm.device.common.domin.IotDeviceBaseCtlReqVo;
+import com.yunfeiyun.agmp.iotm.device.common.domin.IotDeviceBaseListReqVo;
+import com.yunfeiyun.agmp.iotm.device.common.service.IotDeviceBaseService;
+import com.yunfeiyun.agmp.iotm.device.monitor.domin.*;
+
+import java.util.List;
+
+/**
+ * @author 123
+ */
+public interface IotEzvizMonitorService extends IotDeviceBaseService {
+    public List<IotDevice> list(IotDeviceBaseListReqVo iotDeviceBaseListReqVo);
+
+    public IotDevice info(IotDeviceBaseListReqVo iotDeviceBaseListReqVo);
+
+    /**云台控制开始*/
+    public String ptzStart(IotEzvizDevicePtzReqVo iotEzvizDevicePtzReqVo);
+    /**云台控制结束*/
+    public String ptzEnd(IotEzvizDevicePtzReqVo iotEzvizDevicePtzReqVo);
+    /**抓拍*/
+    public String capture(IotEzvizDeviceCaptureReqVo iotEzvizDeviceCaptureReqVo);
+    /**回放*/
+    public String video(IotEzvizDeviceVideoReqVo iotEzvizDeviceVideoReqVo);
+
+    public String address(IotEzvizDeviceAddressGetReqVo iotEzvizDeviceAddressGetReqVo);
+
+    public String refreshStatus(IotDevice iotDevice);
+}

src/main/java/com/yunfeiyun/agmp/iotm/device/monitor/service/impl/IotEzvizMonitorServiceImpl.java

@@ -0,0 +1,269 @@
+package com.yunfeiyun.agmp.iotm.device.monitor.service.impl;
+
+import cn.hutool.core.util.ObjectUtil;
+import com.alibaba.fastjson2.JSONObject;
+import com.yunfeiyun.agmp.common.constant.ErrorCode;
+import com.yunfeiyun.agmp.common.enums.RedisCacheKey;
+import com.yunfeiyun.agmp.common.framework.manager.RedisCacheManager;
+import com.yunfeiyun.agmp.common.utils.uuid.IdUtils;
+import com.yunfeiyun.agmp.iot.common.constant.devicetype.IotDeviceTypeLv1Enum;
+import com.yunfeiyun.agmp.iot.common.constant.devicetype.ServiceNameConst;
+import com.yunfeiyun.agmp.iot.common.domain.IotDevice;
+import com.yunfeiyun.agmp.iot.common.domain.resvo.IotDeviceResVo;
+import com.yunfeiyun.agmp.iot.common.exception.IotBizException;
+import com.yunfeiyun.agmp.iot.common.model.cmd.CmdGroupModel;
+import com.yunfeiyun.agmp.iot.common.model.cmd.CmdModel;
+import com.yunfeiyun.agmp.iot.common.util.tmn.CustomerIdUtil;
+import com.yunfeiyun.agmp.iotm.device.common.domin.IotDeviceBaseCtlReqVo;
+import com.yunfeiyun.agmp.iotm.device.common.domin.IotDeviceBaseListReqVo;
+import com.yunfeiyun.agmp.iotm.device.common.service.IotDeviceBaseService;
+import com.yunfeiyun.agmp.iotm.device.common.service.impl.IotDeviceBaseServiceImpl;
+import com.yunfeiyun.agmp.iotm.device.monitor.domin.*;
+import com.yunfeiyun.agmp.iotm.device.monitor.service.IotEzvizMonitorService;
+import com.yunfeiyun.agmp.iotm.web.mapper.IotDeviceMapper;
+import com.yunfeiyun.agmp.iotm.web.service.IIotCmdtaskService;
+import com.yunfeiyun.agmp.iotm.web.service.IIotDeviceService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import javax.annotation.Resource;
+import java.util.Collections;
+import java.util.LinkedList;
+import java.util.List;
+
+/**
+ * 萤石云监控设备实现
+ *
+ * @author liuyaowen*/
+@Service(value = ServiceNameConst.SERVICE_EZVIZ_MINITOR)
+public class IotEzvizMonitorServiceImpl extends IotDeviceBaseServiceImpl implements IotEzvizMonitorService {
+    @Resource
+    private IotDeviceMapper iotDeviceMapper;
+    @Autowired
+    private IIotCmdtaskService iIotCmdtaskService;
+    @Resource
+    private RedisCacheManager redisCacheManager;
+
+
+
+    @Override
+    public List<IotDevice> list(IotDeviceBaseListReqVo iotDeviceBaseCtlReqVo){
+        return iotDeviceMapper.selectIotDeviceList(iotDeviceBaseCtlReqVo);
+    }
+    @Override
+    public IotDevice info(IotDeviceBaseListReqVo iotDeviceBaseListReqVo){
+        return iotDeviceMapper.selectIotDeviceByDevBid(iotDeviceBaseListReqVo.getDevBid());
+    }
+
+    @Override
+    public String ptzStart(IotEzvizDevicePtzReqVo iotEzvizDevicePtzReqVo) {
+        if(ObjectUtil.isNull(redisCacheManager.getCacheObject(RedisCacheKey.IOT_DEVICE_STATUS,iotEzvizDevicePtzReqVo.getDevBid()))){
+            throw new IotBizException(ErrorCode.FAILURE.getCode(),"设备已离线");
+        }
+        CmdGroupModel cmdGroupModel = new CmdGroupModel();
+        cmdGroupModel.setCId(CustomerIdUtil.getCustomerId());
+        cmdGroupModel.setCmdModels(new LinkedList<>());
+        CmdModel cmdModel = new CmdModel();
+        cmdModel.setDeviceId(iotEzvizDevicePtzReqVo.getDevBid());
+        CmdModel.Cmd cmd = new CmdModel.Cmd();
+        cmd.setFunc("ptzStart");
+        cmd.setRetry(0L);
+        JSONObject params = new JSONObject();
+        String[] devCodeArray = iotEzvizDevicePtzReqVo.getDevCode().split("-");
+        params.put("deviceSerial", devCodeArray[0]);
+        params.put("channelNo", devCodeArray[1]);
+        params.put("direction", iotEzvizDevicePtzReqVo.getDirection());
+        params.put("speed", iotEzvizDevicePtzReqVo.getSpeed());
+        cmd.setJsons(params);
+        cmdModel.setFinalStatus(false);
+        cmdModel.setTimeout(10);
+        cmdModel.setNeedcheckStatus(false);
+        cmdModel.setCmdDistribution(cmd);
+        cmdGroupModel.getCmdModels().add(Collections.singletonList(cmdModel));
+        cmdGroupModel.setRequestId(IdUtils.fastUUID());
+        cmdGroupModel.setDevCode(iotEzvizDevicePtzReqVo.getDevCode());
+        cmdGroupModel.setCtBiztype("3");
+        cmdGroupModel.setCtBiztitle(IotDeviceTypeLv1Enum.JKSB.getName() + "：" + iotEzvizDevicePtzReqVo.getDevCode());
+        cmdGroupModel.setCtDevtype(iotEzvizDevicePtzReqVo.getDevtypeBid());
+        
+        iIotCmdtaskService.handInternalCmd(cmdGroupModel);
+        return cmdGroupModel.getTaskUuid();
+    }
+
+    @Override
+    public String ptzEnd(IotEzvizDevicePtzReqVo iotEzvizDevicePtzReqVo) {
+        if(ObjectUtil.isNull(redisCacheManager.getCacheObject(RedisCacheKey.IOT_DEVICE_STATUS,iotEzvizDevicePtzReqVo.getDevBid()))){
+            throw new IotBizException(ErrorCode.FAILURE.getCode(),"设备已离线");
+        }
+        String[] devCodeArray = iotEzvizDevicePtzReqVo.getDevCode().split("-");
+        CmdGroupModel cmdGroupModel = new CmdGroupModel();
+        cmdGroupModel.setCId(CustomerIdUtil.getCustomerId());
+        cmdGroupModel.setCmdModels(new LinkedList<>());
+        CmdModel cmdModel = new CmdModel();
+        cmdModel.setDeviceId(iotEzvizDevicePtzReqVo.getDevBid());
+        CmdModel.Cmd cmd = new CmdModel.Cmd();
+        cmd.setFunc("ptzEnd");
+        cmd.setRetry(0L);
+        JSONObject params = new JSONObject();
+        params.put("deviceSerial", devCodeArray[0]);
+        params.put("channelNo", devCodeArray[1]);
+        params.put("direction", iotEzvizDevicePtzReqVo.getDirection());
+        cmd.setJsons(params);
+        cmdModel.setFinalStatus(false);
+        cmdModel.setTimeout(10);
+        cmdModel.setNeedcheckStatus(false);
+        cmdModel.setCmdDistribution(cmd);
+        cmdGroupModel.getCmdModels().add(Collections.singletonList(cmdModel));
+        cmdGroupModel.setRequestId(IdUtils.fastUUID());
+        cmdGroupModel.setDevCode(iotEzvizDevicePtzReqVo.getDevCode());
+        cmdGroupModel.setCtBiztype("3");
+        cmdGroupModel.setCtBiztitle(IotDeviceTypeLv1Enum.JKSB.getName() + "：" + iotEzvizDevicePtzReqVo.getDevCode());
+        cmdGroupModel.setCtDevtype(iotEzvizDevicePtzReqVo.getDevtypeBid());
+        iIotCmdtaskService.handInternalCmd(cmdGroupModel);
+        return cmdGroupModel.getTaskUuid();
+    }
+
+    @Override
+    public String capture(IotEzvizDeviceCaptureReqVo iotEzvizDeviceCaptureReqVo) {
+        if(ObjectUtil.isNull(redisCacheManager.getCacheObject(RedisCacheKey.IOT_DEVICE_STATUS,iotEzvizDeviceCaptureReqVo.getDevBid()))){
+            throw new IotBizException(ErrorCode.FAILURE.getCode(),"设备已离线");
+        }
+        String[] devCodeArray = iotEzvizDeviceCaptureReqVo.getDevCode().split("-");
+        CmdGroupModel cmdGroupModel = new CmdGroupModel();
+        cmdGroupModel.setCId(CustomerIdUtil.getCustomerId());
+        cmdGroupModel.setCmdModels(new LinkedList<>());
+        CmdModel cmdModel = new CmdModel();
+        cmdModel.setDeviceId(iotEzvizDeviceCaptureReqVo.getDevBid());
+        CmdModel.Cmd cmd = new CmdModel.Cmd();
+        cmd.setFunc("capture");
+        cmd.setRetry(0L);
+        JSONObject params = new JSONObject();
+        params.put("deviceSerial", devCodeArray[0]);
+        params.put("channelNo", devCodeArray[1]);
+        params.put("quality", iotEzvizDeviceCaptureReqVo.getQuality());
+        cmd.setJsons(params);
+        cmdModel.setFinalStatus(false);
+        cmdModel.setTimeout(10);
+        cmdModel.setNeedcheckStatus(false);
+        cmdModel.setCmdDistribution(cmd);
+        cmdGroupModel.getCmdModels().add(Collections.singletonList(cmdModel));
+        cmdGroupModel.setRequestId(IdUtils.fastUUID());
+        cmdGroupModel.setDevCode(iotEzvizDeviceCaptureReqVo.getDevCode());
+        cmdGroupModel.setCtBiztype("3");
+        cmdGroupModel.setCtBiztitle(IotDeviceTypeLv1Enum.JKSB.getName() + "：" + iotEzvizDeviceCaptureReqVo.getDevCode());
+        cmdGroupModel.setCtDevtype(iotEzvizDeviceCaptureReqVo.getDevtypeBid());
+        iIotCmdtaskService.handInternalCmd(cmdGroupModel);
+        return cmdGroupModel.getTaskUuid();
+    }
+
+    @Override
+    public String video(IotEzvizDeviceVideoReqVo iotEzvizDeviceVideoReqVo) {
+        if(ObjectUtil.isNull(redisCacheManager.getCacheObject(RedisCacheKey.IOT_DEVICE_STATUS,iotEzvizDeviceVideoReqVo.getDevBid()))){
+            throw new IotBizException(ErrorCode.FAILURE.getCode(),"设备已离线");
+        }
+        String[] devCodeArray = iotEzvizDeviceVideoReqVo.getDevCode().split("-");
+        CmdGroupModel cmdGroupModel = new CmdGroupModel();
+        cmdGroupModel.setCId(CustomerIdUtil.getCustomerId());
+        cmdGroupModel.setCmdModels(new LinkedList<>());
+        CmdModel cmdModel = new CmdModel();
+        cmdModel.setDeviceId(iotEzvizDeviceVideoReqVo.getDevBid());
+        CmdModel.Cmd cmd = new CmdModel.Cmd();
+        cmd.setFunc("video");
+        cmd.setRetry(0L);
+        JSONObject params = new JSONObject();
+        params.put("deviceSerial", devCodeArray[0]);
+        params.put("channelNo", devCodeArray[1]);
+        params.put("startTime", iotEzvizDeviceVideoReqVo.getStartTime());
+        params.put("endTime", iotEzvizDeviceVideoReqVo.getEndTime());
+        params.put("recType", iotEzvizDeviceVideoReqVo.getRecType());
+        params.put("version", iotEzvizDeviceVideoReqVo.getVersion());
+        params.put("pageSize", iotEzvizDeviceVideoReqVo.getPageSize());
+        cmd.setJsons(params);
+        cmdModel.setFinalStatus(false);
+        cmdModel.setTimeout(10);
+        cmdModel.setNeedcheckStatus(false);
+        cmdModel.setCmdDistribution(cmd);
+        cmdGroupModel.getCmdModels().add(Collections.singletonList(cmdModel));
+        cmdGroupModel.setRequestId(IdUtils.fastUUID());
+        cmdGroupModel.setDevCode(iotEzvizDeviceVideoReqVo.getDevCode());
+        cmdGroupModel.setCtBiztype("3");
+        cmdGroupModel.setCtBiztitle(IotDeviceTypeLv1Enum.JKSB.getName() + "：" + iotEzvizDeviceVideoReqVo.getDevCode());
+        cmdGroupModel.setCtDevtype(iotEzvizDeviceVideoReqVo.getDevtypeBid());
+        iIotCmdtaskService.handInternalCmd(cmdGroupModel);
+        return cmdGroupModel.getTaskUuid();
+    }
+
+    @Override
+    public String address(IotEzvizDeviceAddressGetReqVo iotEzvizDeviceAddressGetReqVo) {
+        if(ObjectUtil.isNull(redisCacheManager.getCacheObject(RedisCacheKey.IOT_DEVICE_STATUS,iotEzvizDeviceAddressGetReqVo.getDevBid()))){
+            throw new IotBizException(ErrorCode.FAILURE.getCode(),"设备已离线");
+        }
+        String[] devCodeArray = iotEzvizDeviceAddressGetReqVo.getDevCode().split("-");
+        CmdGroupModel cmdGroupModel = new CmdGroupModel();
+        cmdGroupModel.setCId(CustomerIdUtil.getCustomerId());
+        cmdGroupModel.setCmdModels(new LinkedList<>());
+        CmdModel cmdModel = new CmdModel();
+        cmdModel.setDeviceId(iotEzvizDeviceAddressGetReqVo.getDevBid());
+        CmdModel.Cmd cmd = new CmdModel.Cmd();
+        cmd.setFunc("address");
+        cmd.setRetry(0L);
+        JSONObject params = new JSONObject();
+        params.put("deviceSerial", devCodeArray[0]);
+        params.put("channelNo", devCodeArray[1]);
+        params.put("startTime", iotEzvizDeviceAddressGetReqVo.getStartTime());
+        params.put("stopTime", iotEzvizDeviceAddressGetReqVo.getStopTime());
+        params.put("protocol", iotEzvizDeviceAddressGetReqVo.getProtocol());
+        params.put("code", iotEzvizDeviceAddressGetReqVo.getCode());
+        params.put("expireTime", iotEzvizDeviceAddressGetReqVo.getExpireTime());
+        params.put("type", iotEzvizDeviceAddressGetReqVo.getType());
+        params.put("quality", iotEzvizDeviceAddressGetReqVo.getQuality());
+        params.put("supportH265", iotEzvizDeviceAddressGetReqVo.getSupportH265());
+        params.put("playbackSpeed", iotEzvizDeviceAddressGetReqVo.getPlaybackSpeed());
+        params.put("gbchannel", iotEzvizDeviceAddressGetReqVo.getGbchannel());
+        cmd.setJsons(params);
+        cmdModel.setFinalStatus(false);
+        cmdModel.setTimeout(10);
+        cmdModel.setNeedcheckStatus(false);
+        cmdModel.setCmdDistribution(cmd);
+        cmdGroupModel.getCmdModels().add(Collections.singletonList(cmdModel));
+        cmdGroupModel.setRequestId(IdUtils.fastUUID());
+        cmdGroupModel.setDevCode(iotEzvizDeviceAddressGetReqVo.getDevCode());
+        cmdGroupModel.setCtBiztype("3");
+        cmdGroupModel.setCtBiztitle(IotDeviceTypeLv1Enum.JKSB.getName() + "：" + iotEzvizDeviceAddressGetReqVo.getDevCode());
+        cmdGroupModel.setCtDevtype(iotEzvizDeviceAddressGetReqVo.getDevtypeBid());
+
+        iIotCmdtaskService.handInternalCmd(cmdGroupModel);
+        return cmdGroupModel.getTaskUuid();
+    }
+
+    @Override
+    public String refreshStatus(IotDevice iotDevice) {
+        String[] devCodeArray = iotDevice.getDevCode().split("-");
+        CmdGroupModel cmdGroupModel = new CmdGroupModel();
+        cmdGroupModel.setCId(CustomerIdUtil.getCustomerId());
+        cmdGroupModel.setCmdModels(new LinkedList<>());
+        CmdModel cmdModel = new CmdModel();
+        cmdModel.setDeviceId(iotDevice.getDevBid());
+        CmdModel.Cmd cmd = new CmdModel.Cmd();
+        cmd.setFunc("refreshStatus");
+        cmd.setRetry(0L);
+        JSONObject params = new JSONObject();
+        params.put("devBid", iotDevice.getDevBid());
+        params.put("devCode",iotDevice.getDevCode());
+        cmd.setJsons(params);
+        cmdModel.setFinalStatus(false);
+        cmdModel.setTimeout(10);
+        cmdModel.setNeedcheckStatus(false);
+        cmdModel.setCmdDistribution(cmd);
+        cmdGroupModel.getCmdModels().add(Collections.singletonList(cmdModel));
+        cmdGroupModel.setRequestId(IdUtils.fastUUID());
+        cmdGroupModel.setDevCode(devCodeArray[0]);
+        cmdGroupModel.setCtBiztype("3");
+        cmdGroupModel.setCtBiztitle(IotDeviceTypeLv1Enum.JKSB.getName() + "：" + iotDevice.getDevCode());
+        cmdGroupModel.setCtDevtype(iotDevice.getDevtypeBid());
+        cmdGroupModel.setCtParam(params.toJSONString());
+        iIotCmdtaskService.handInternalCmd(cmdGroupModel);
+        return cmdGroupModel.getTaskUuid();
+    }
+
+}

src/main/java/com/yunfeiyun/agmp/iotm/web/controller/IotCmdexecController.java

@@ -0,0 +1,92 @@
+package com.yunfeiyun.agmp.iotm.web.controller;
+
+import com.yunfeiyun.agmp.common.annotation.Log;
+import com.yunfeiyun.agmp.common.core.controller.BaseController;
+import com.yunfeiyun.agmp.common.core.domain.AjaxResult;
+import com.yunfeiyun.agmp.common.core.page.TableDataInfo;
+import com.yunfeiyun.agmp.common.enums.BusinessType;
+import com.yunfeiyun.agmp.common.utils.poi.ExcelUtil;
+import com.yunfeiyun.agmp.iot.common.domain.IotCmdexec;
+
+import com.yunfeiyun.agmp.iotm.web.service.IIotCmdexecService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.web.bind.annotation.*;
+
+import javax.servlet.http.HttpServletResponse;
+import java.util.List;
+
+/**
+ * 指令执行Controller
+ *
+ * @author 杨晓辉
+ * @date 2024-01-04
+ */
+@RestController
+@RequestMapping("/iot/cmdexec")
+public class IotCmdexecController extends BaseController {
+    @Autowired
+    private IIotCmdexecService iotCmdexecService;
+
+    /**
+     * 查询指令执行列表
+     */
+    @PreAuthorize("@ss.hasPermi('iot:cmdexec:list')")
+    @GetMapping("/list")
+    public TableDataInfo list(IotCmdexec iotCmdexec) {
+        startPage();
+        List<IotCmdexec> list = iotCmdexecService.selectIotCmdexecList(iotCmdexec);
+        return getDataTable(list);
+    }
+
+    /**
+     * 导出指令执行列表
+     */
+    @PreAuthorize("@ss.hasPermi('iot:cmdexec:export')")
+    @Log(title = "指令执行", businessType = BusinessType.EXPORT)
+    @PostMapping("/export")
+    public void export(HttpServletResponse response, IotCmdexec iotCmdexec) {
+        List<IotCmdexec> list = iotCmdexecService.selectIotCmdexecList(iotCmdexec);
+        ExcelUtil<IotCmdexec> util = new ExcelUtil<IotCmdexec>(IotCmdexec.class);
+        util.exportExcel(response, list, "指令执行数据");
+    }
+
+    /**
+     * 获取指令执行详细信息
+     */
+    @PreAuthorize("@ss.hasPermi('iot:cmdexec:query')")
+    @GetMapping(value = "/info")
+    public AjaxResult getInfo(@RequestParam("id") Long id) {
+        return success(iotCmdexecService.selectIotCmdexecById(id));
+    }
+
+    /**
+     * 新增指令执行
+     */
+    @PreAuthorize("@ss.hasPermi('iot:cmdexec:add')")
+    @Log(title = "指令执行", businessType = BusinessType.INSERT)
+    @PostMapping("/add")
+    public AjaxResult add(@RequestBody IotCmdexec iotCmdexec) {
+        return toAjax(iotCmdexecService.insertIotCmdexec(iotCmdexec));
+    }
+
+    /**
+     * 修改指令执行
+     */
+    @PreAuthorize("@ss.hasPermi('iot:cmdexec:edit')")
+    @Log(title = "指令执行", businessType = BusinessType.UPDATE)
+    @PutMapping("/edit")
+    public AjaxResult edit(@RequestBody IotCmdexec iotCmdexec) {
+        return toAjax(iotCmdexecService.updateIotCmdexec(iotCmdexec));
+    }
+
+    /**
+     * 删除指令执行
+     */
+    @PreAuthorize("@ss.hasPermi('iot:cmdexec:remove')")
+    @Log(title = "指令执行", businessType = BusinessType.DELETE)
+    @DeleteMapping("/delete")
+    public AjaxResult remove(@RequestParam("ids") Long[] ids) {
+        return toAjax(iotCmdexecService.deleteIotCmdexecByIds(ids));
+    }
+}

src/main/java/com/yunfeiyun/agmp/iotm/web/controller/IotCmdlogController.java

@@ -0,0 +1,131 @@
+package com.yunfeiyun.agmp.iotm.web.controller;
+
+import cn.hutool.core.bean.BeanUtil;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.github.pagehelper.PageInfo;
+import com.yunfeiyun.agmp.common.constant.ErrorCode;
+import com.yunfeiyun.agmp.common.core.page.TableDataInfo;
+import com.yunfeiyun.agmp.common.core.page.TableSupport;
+import com.yunfeiyun.agmp.common.utils.JSONUtils;
+import com.yunfeiyun.agmp.common.utils.PageUtils;
+import com.yunfeiyun.agmp.common.utils.StringUtils;
+import com.yunfeiyun.agmp.iot.common.constant.IotErrorCode;
+import com.yunfeiyun.agmp.iot.common.domain.IotCmdexec;
+import com.yunfeiyun.agmp.iot.common.domain.IotCmdlog;
+import com.yunfeiyun.agmp.iot.common.domain.IotCmdtask;
+import com.yunfeiyun.agmp.iot.common.domain.reqvo.IotCmdLogReqVo;
+import com.yunfeiyun.agmp.iot.common.exception.IotBizException;
+import com.yunfeiyun.agmp.iot.common.service.MongoService;
+import com.yunfeiyun.agmp.iotm.common.controller.BaseController;
+import com.yunfeiyun.agmp.iotm.web.service.IIotCmdexecService;
+import com.yunfeiyun.agmp.iotm.web.service.IIotCmdtaskService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import javax.annotation.Resource;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+@RestController
+@RequestMapping("/iot/cmd/log")
+public class IotCmdlogController extends BaseController {
+
+    @Resource
+    private MongoService mongoService;
+
+    @Autowired
+    private IIotCmdtaskService iIotCmdtaskService;
+
+    @Autowired
+    private IIotCmdexecService iIotCmdexecService;
+
+    /**
+     * 查询物候摄像机数据列表
+     */
+    @RequestMapping("/list")
+    public TableDataInfo list(IotCmdLogReqVo reqVo) {
+        String devBizId = reqVo.getDevBid();
+        if (StringUtils.isEmpty(devBizId)) {
+            throw new IotBizException(IotErrorCode.FAILURE.getCode(), "设备id不可为空");
+        }
+        Map<String, Object> map = BeanUtil.beanToMap(reqVo);
+        if (StringUtils.isNotEmpty(reqVo.getStartTime()) && StringUtils.isEmpty(reqVo.getEndTime())) {
+            map.put("gte_clogCreateddate", reqVo.getStartTime());
+        }
+        if (StringUtils.isEmpty(reqVo.getStartTime()) && StringUtils.isNotEmpty(reqVo.getEndTime())) {
+            map.put("lte_clogCreateddate", reqVo.getEndTime());
+        }
+        if (StringUtils.isNotEmpty(reqVo.getStartTime()) && StringUtils.isNotEmpty(reqVo.getEndTime())) {
+            map.put("time_clogCreateddate", reqVo.getStartTime() + "," + reqVo.getEndTime());
+        }
+        map.remove("startTime");
+        map.remove("endTime");
+        // 查询指令日志
+        IPage<IotCmdlog> iotCmdlogs = mongoService.findListPage(IotCmdlog.class, map, TableSupport.buildPageRequest());
+        // 查询执行执行结果
+        List<IotCmdlog> iotCmdlogs1 = iotCmdlogs.getRecords();
+        // 重新定义返回的结构，追加的新字段，不改之前结构
+        List iotCmdlogsList = new ArrayList();
+        if (iotCmdlogs1 != null && iotCmdlogs1.size() != 0) {
+            String[] ceBids = new String[iotCmdlogs1.size()];
+            int i = 0;
+            for (IotCmdlog iotCmdlog : iotCmdlogs1) {
+                // 指令标识
+                String ceBid = iotCmdlog.getCeBid();
+                ceBids[i] = ceBid;
+                i++;
+            }
+            // 一次性批量 执行执行对应的结果
+            List<IotCmdexec> iotCmdexecs = iIotCmdexecService.selectCmdExeByCeBids(ceBids);
+            Map<String, IotCmdexec> ma = new HashMap();
+            for (IotCmdexec iotCmdexec : iotCmdexecs) {
+                ma.put(iotCmdexec.getCeBid(), iotCmdexec);
+            }
+
+            // 将原来obj转map，方便追加字段，没有直接转map工具
+            for (IotCmdlog iotCmdlog : iotCmdlogs1) {
+                String ceBid = iotCmdlog.getCeBid();
+                Map row2 = JSONUtils.toMap(JSONUtils.toJSONString(iotCmdlog));
+                row2.put("result", ma.get(ceBid));
+                iotCmdlogsList.add(row2);
+            }
+
+        }
+        // 重新构建iPage
+        IPage data = new Page<>();
+        data.setTotal(iotCmdlogs.getTotal());
+        data.setCurrent(iotCmdlogs.getCurrent());
+        data.setPages(iotCmdlogs.getPages());
+        data.setRecords(iotCmdlogsList);
+        data.setSize(iotCmdlogs.getSize());
+        return getDataTable(data);
+    }
+
+
+    /**
+     * 查询物候摄像机数据列表
+     */
+    @RequestMapping("/task/list")
+    public TableDataInfo getTaskLog(IotCmdtask iotCmdtask) {
+        startPage();
+        return getDataTable(iIotCmdtaskService.selectIotCmdtaskList(iotCmdtask));
+    }
+
+    @Override
+    protected TableDataInfo getDataTable(List<?> list) {
+        TableDataInfo rspData = new TableDataInfo();
+        rspData.setCode(ErrorCode.SUCCESS.getCode());
+        rspData.setMsg(ErrorCode.SUCCESS.getMessage());
+        rspData.setData(list);
+        rspData.setTotal(new PageInfo(list).getTotal());
+        return rspData;
+    }
+
+    protected void startPage() {
+        PageUtils.startPage();
+    }
+}

src/main/java/com/yunfeiyun/agmp/iotm/web/controller/IotCmdtaskController.java

@@ -0,0 +1,110 @@
+package com.yunfeiyun.agmp.iotm.web.controller;
+
+import com.yunfeiyun.agmp.common.annotation.Log;
+import com.yunfeiyun.agmp.common.core.controller.BaseController;
+import com.yunfeiyun.agmp.common.core.domain.AjaxResult;
+import com.yunfeiyun.agmp.common.core.page.TableDataInfo;
+import com.yunfeiyun.agmp.common.enums.BusinessType;
+import com.yunfeiyun.agmp.common.framework.manager.RedisCacheManager;
+import com.yunfeiyun.agmp.common.utils.poi.ExcelUtil;
+import com.yunfeiyun.agmp.iot.common.domain.IotCmdlog;
+import com.yunfeiyun.agmp.iot.common.domain.IotCmdtask;
+import com.yunfeiyun.agmp.iot.common.service.MongoService;
+import com.yunfeiyun.agmp.iotm.web.domain.resvo.IotCmdTaskLogResVo;
+import com.yunfeiyun.agmp.iotm.web.service.IIotCmdtaskService;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.web.bind.annotation.*;
+
+import javax.servlet.http.HttpServletResponse;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 设备指令任务Controller
+ *
+ * @author 杨晓辉
+ * @date 2024-01-04
+ */
+@RestController
+@RequestMapping("/iot/cmdtask")
+public class IotCmdtaskController extends BaseController {
+    @Autowired
+    private IIotCmdtaskService iotCmdtaskService;
+    @Autowired
+    private RedisCacheManager redisCacheManager;
+    @Autowired
+    private MongoService mongoService;
+
+    /**
+     * 查询设备指令任务列表
+     */
+    @PreAuthorize("@ss.hasPermi('iot:cmdtask:list')")
+    @GetMapping("/list")
+    public TableDataInfo list(IotCmdtask iotCmdtask) {
+        iotCmdtask.setCtLogtype(1);
+        startPage();
+        List<IotCmdtask> list = iotCmdtaskService.selectIotCmdtaskList(iotCmdtask);
+        return getDataTable(list);
+    }
+
+    /**
+     * 导出设备指令任务列表
+     */
+    @PreAuthorize("@ss.hasPermi('iot:cmdtask:export')")
+    @Log(title = "设备指令任务", businessType = BusinessType.EXPORT)
+    @PostMapping("/export")
+    public void export(HttpServletResponse response, IotCmdtask iotCmdtask) {
+        List<IotCmdtask> list = iotCmdtaskService.selectIotCmdtaskList(iotCmdtask);
+        ExcelUtil<IotCmdtask> util = new ExcelUtil<IotCmdtask>(IotCmdtask.class);
+        util.exportExcel(response, list, "设备指令任务数据");
+    }
+
+    /**
+     * 获取设备指令任务详细信息
+     */
+    @PreAuthorize("@ss.hasPermi('iot:cmdtask:query')")
+    @GetMapping(value = "/info")
+    public AjaxResult getInfo(@RequestParam("id") Long id) {
+        return success(iotCmdtaskService.selectIotCmdtaskById(id));
+    }
+
+    /**
+     * 修改设备指令任务
+     */
+    @PreAuthorize("@ss.hasPermi('iot:cmdtask:edit')")
+    @Log(title = "设备指令任务", businessType = BusinessType.UPDATE)
+    @PutMapping("/edit")
+    public AjaxResult edit(@RequestBody IotCmdtask iotCmdtask) {
+        return toAjax(iotCmdtaskService.updateIotCmdtask(iotCmdtask));
+    }
+
+    /**
+     * 删除设备指令任务
+     */
+    @PreAuthorize("@ss.hasPermi('iot:cmdtask:remove')")
+    @Log(title = "设备指令任务", businessType = BusinessType.DELETE)
+    @DeleteMapping("/delete")
+    public AjaxResult remove(@RequestParam("ids") Long[] ids) {
+        return toAjax(iotCmdtaskService.deleteIotCmdtaskByIds(ids));
+    }
+
+    /**
+     * 获取对应请求标识指令任务
+     */
+    @PreAuthorize("@ss.hasPermi('iot:cmdtask:result')")
+    @Log(title = "设备指令任务结果", businessType = BusinessType.DELETE)
+    @GetMapping("/result")
+    public AjaxResult result(@RequestParam("taskId") String taskId) {
+        IotCmdtask iotCmdtask = iotCmdtaskService.selectIotCmdtaskByCtBid(taskId);
+        IotCmdTaskLogResVo iotCmdTaskLogResVo = new IotCmdTaskLogResVo();
+        BeanUtils.copyProperties(iotCmdtask, iotCmdTaskLogResVo);
+        Map<String, Object> map = new HashMap<>();
+        map.put("ctBid", taskId);
+        List<IotCmdlog> iotCmdlogList = mongoService.findAll(IotCmdlog.class, map);
+        iotCmdTaskLogResVo.setIotCmdlogList(iotCmdlogList);
+        return success(iotCmdTaskLogResVo);
+    }
+}

src/main/java/com/yunfeiyun/agmp/iotm/web/controller/IotDeviceCommonController.java

@@ -0,0 +1,51 @@
+package com.yunfeiyun.agmp.iotm.web.controller;
+
+import com.yunfeiyun.agmp.common.core.domain.AjaxResult;
+import com.yunfeiyun.agmp.common.core.page.TableDataInfo;
+import com.yunfeiyun.agmp.common.utils.SecurityUtils;
+import com.yunfeiyun.agmp.iot.common.domain.IotDevice;
+import com.yunfeiyun.agmp.iotm.common.controller.BaseController;
+import com.yunfeiyun.agmp.iotm.device.common.domin.IotDeviceBaseCtlReqVo;
+import com.yunfeiyun.agmp.iotm.device.common.domin.IotDeviceBaseListReqVo;
+import com.yunfeiyun.agmp.iotm.device.common.service.IotDeviceCommonService;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.web.bind.annotation.*;
+
+import javax.annotation.Resource;
+import java.util.List;
+
+@RestController
+@RequestMapping("/iot/device/common")
+public class IotDeviceCommonController extends BaseController {
+    @Resource
+    private IotDeviceCommonService iotDeviceCommonService;
+    /**
+     * 查询设备基础列表
+     */
+    @PreAuthorize("@ss.hasPermi('iot:device:detail:list')")
+    @GetMapping("/list")
+    public TableDataInfo list(IotDeviceBaseListReqVo iotDeviceBaseListReqVo) {
+        startPage();
+        iotDeviceBaseListReqVo.setTid(SecurityUtils.getTid());
+        List<IotDevice> list = iotDeviceCommonService.list(iotDeviceBaseListReqVo);
+        return getDataTable(list);
+    }
+    /**
+     * 设备控制公共接口
+     * */
+    @PreAuthorize("@ss.hasPermi('iot:device:common:ctl')")
+    @PostMapping("/ctl")
+    public AjaxResult ctl(IotDeviceBaseCtlReqVo iotDeviceBaseCtlReqVo){
+        return success(iotDeviceCommonService.ctl(iotDeviceBaseCtlReqVo));
+    }
+
+    /**设备详情公共接口*/
+    /**
+     * 设备控制公共接口
+     * */
+    @PreAuthorize("@ss.hasPermi('iot:device:common:info')")
+    @PostMapping("/info/{devBid}")
+    public AjaxResult info(@PathVariable("devBid") String devBid){
+        return success(iotDeviceCommonService.info(devBid));
+    }
+}

src/main/java/com/yunfeiyun/agmp/iotm/web/controller/IotDeviceController.java

@@ -4,8 +4,11 @@ import java.util.List;
 import javax.servlet.http.HttpServletResponse;
 import javax.validation.Valid;
 
+import com.yunfeiyun.agmp.common.utils.SecurityUtils;
 import com.yunfeiyun.agmp.iot.common.domain.IotDevice;
+import com.yunfeiyun.agmp.iotm.device.common.domin.IotDeviceBaseCtlReqVo;
 import com.yunfeiyun.agmp.iotm.web.domain.reqvo.IotDeviceAddReqVo;
+import com.yunfeiyun.agmp.iotm.device.common.domin.IotDeviceBaseListReqVo;
 import com.yunfeiyun.agmp.iotm.web.service.IIotDeviceService;
 import org.springframework.security.access.prepost.PreAuthorize;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -58,17 +61,6 @@ public class IotDeviceController extends BaseController
         return getDataTable(list);
     }
     /**
-     * 查询设备基础列表
-     */
-    @PreAuthorize("@ss.hasPermi('iot:device:detail:list')")
-    @GetMapping("/detail/list")
-    public TableDataInfo detailList(IotDevice iotDevice) {
-        startPage();
-        List<IotDevice> list = iotDeviceService.selectIotDeviceDetailResVoList(iotDevice);
-        return getDataTable(list);
-    }
-
-    /**
      * 导出设备基础列表
      */
     @PreAuthorize("@ss.hasPermi('iot:device:export')")
@@ -88,7 +80,6 @@ public class IotDeviceController extends BaseController
     public AjaxResult getInfo(@PathVariable("devBid") String devBid) {
         return success(iotDeviceService.selectIotDeviceByDevBid(devBid));
     }
-
     /**
      * 修改设备基础
      */
@@ -98,7 +89,6 @@ public class IotDeviceController extends BaseController
     public AjaxResult edit(@RequestBody IotDevice iotDevice) {
         return toAjax(iotDeviceService.updateIotDevice(iotDevice));
     }
-
     /**
      * 删除设备基础
      */

src/main/java/com/yunfeiyun/agmp/iotm/web/domain/resvo/IotCmdTaskLogResVo.java

@@ -0,0 +1,13 @@
+package com.yunfeiyun.agmp.iotm.web.domain.resvo;
+
+import com.yunfeiyun.agmp.iot.common.domain.IotCmdlog;
+import com.yunfeiyun.agmp.iot.common.domain.IotCmdtask;
+import lombok.Data;
+
+import java.util.List;
+
+@Data
+public class IotCmdTaskLogResVo extends IotCmdtask {
+    private List<IotCmdlog> iotCmdlogList;
+
+}

src/main/java/com/yunfeiyun/agmp/iotm/web/mapper/IotCmdexecMapper.java

@@ -0,0 +1,65 @@
+package com.yunfeiyun.agmp.iotm.web.mapper;
+
+
+import com.yunfeiyun.agmp.iot.common.domain.IotCmdexec;
+
+import java.util.List;
+
+/**
+ * 指令执行Mapper接口
+ *
+ * @author 杨晓辉
+ * @date 2024-01-04
+ */
+public interface IotCmdexecMapper
+{
+    /**
+     * 查询指令执行
+     *
+     * @param id 指令执行主键
+     * @return 指令执行
+     */
+    public IotCmdexec selectIotCmdexecById(Long id);
+
+    /**
+     * 查询指令执行列表
+     *
+     * @param iotCmdexec 指令执行
+     * @return 指令执行集合
+     */
+    public List<IotCmdexec> selectIotCmdexecList(IotCmdexec iotCmdexec);
+
+    /**
+     * 新增指令执行
+     *
+     * @param iotCmdexec 指令执行
+     * @return 结果
+     */
+    public int insertIotCmdexec(IotCmdexec iotCmdexec);
+
+    /**
+     * 修改指令执行
+     *
+     * @param iotCmdexec 指令执行
+     * @return 结果
+     */
+    public int updateIotCmdexec(IotCmdexec iotCmdexec);
+
+    /**
+     * 删除指令执行
+     *
+     * @param id 指令执行主键
+     * @return 结果
+     */
+    public int deleteIotCmdexecById(Long id);
+
+    /**
+     * 批量删除指令执行
+     *
+     * @param ids 需要删除的数据主键集合
+     * @return 结果
+     */
+    public int deleteIotCmdexecByIds(Long[] ids);
+
+    List<IotCmdexec> selectCmdExeByCeBids(String[] ids);
+}

src/main/java/com/yunfeiyun/agmp/iotm/web/mapper/IotCmdtaskMapper.java

@@ -0,0 +1,65 @@
+package com.yunfeiyun.agmp.iotm.web.mapper;
+
+
+import com.yunfeiyun.agmp.iot.common.domain.IotCmdtask;
+
+import java.util.List;
+
+/**
+ * 设备指令任务Mapper接口
+ * 
+ * @author 杨晓辉
+ * @date 2024-01-04
+ */
+public interface IotCmdtaskMapper 
+{
+    /**
+     * 查询设备指令任务
+     * 
+     * @param id 设备指令任务主键
+     * @return 设备指令任务
+     */
+    public IotCmdtask selectIotCmdtaskById(Long id);
+
+    /**
+     * 查询设备指令任务列表
+     * 
+     * @param iotCmdtask 设备指令任务
+     * @return 设备指令任务集合
+     */
+    public List<IotCmdtask> selectIotCmdtaskList(IotCmdtask iotCmdtask);
+
+    /**
+     * 新增设备指令任务
+     * 
+     * @param iotCmdtask 设备指令任务
+     * @return 结果
+     */
+    public int insertIotCmdtask(IotCmdtask iotCmdtask);
+
+    /**
+     * 修改设备指令任务
+     * 
+     * @param iotCmdtask 设备指令任务
+     * @return 结果
+     */
+    public int updateIotCmdtask(IotCmdtask iotCmdtask);
+
+    /**
+     * 删除设备指令任务
+     * 
+     * @param id 设备指令任务主键
+     * @return 结果
+     */
+    public int deleteIotCmdtaskById(Long id);
+
+    /**
+     * 批量删除设备指令任务
+     * 
+     * @param ids 需要删除的数据主键集合
+     * @return 结果
+     */
+    public int deleteIotCmdtaskByIds(Long[] ids);
+
+    IotCmdtask selectIotCmdtaskByCtBid(String taskId);
+}

src/main/java/com/yunfeiyun/agmp/iotm/web/service/IIotCmdexecService.java

@@ -0,0 +1,65 @@
+package com.yunfeiyun.agmp.iotm.web.service;
+
+
+import com.yunfeiyun.agmp.iot.common.domain.IotCmdexec;
+
+import java.util.List;
+
+/**
+ * 指令执行Service接口
+ *
+ * @author 杨晓辉
+ * @date 2024-01-04
+ */
+public interface IIotCmdexecService
+{
+    /**
+     * 查询指令执行
+     *
+     * @param id 指令执行主键
+     * @return 指令执行
+     */
+    public IotCmdexec selectIotCmdexecById(Long id);
+
+    /**
+     * 查询指令执行列表
+     *
+     * @param iotCmdexec 指令执行
+     * @return 指令执行集合
+     */
+    public List<IotCmdexec> selectIotCmdexecList(IotCmdexec iotCmdexec);
+
+    /**
+     * 新增指令执行
+     *
+     * @param iotCmdexec 指令执行
+     * @return 结果
+     */
+    public int insertIotCmdexec(IotCmdexec iotCmdexec);
+
+    /**
+     * 修改指令执行
+     *
+     * @param iotCmdexec 指令执行
+     * @return 结果
+     */
+    public int updateIotCmdexec(IotCmdexec iotCmdexec);
+
+    /**
+     * 批量删除指令执行
+     *
+     * @param ids 需要删除的指令执行主键集合
+     * @return 结果
+     */
+    public int deleteIotCmdexecByIds(Long[] ids);
+
+    /**
+     * 删除指令执行信息
+     *
+     * @param id 指令执行主键
+     * @return 结果
+     */
+    public int deleteIotCmdexecById(Long id);
+
+    public List<IotCmdexec> selectCmdExeByCeBids(String[] ids);
+}

src/main/java/com/yunfeiyun/agmp/iotm/web/service/IIotCmdlogService.java

@@ -0,0 +1,20 @@
+package com.yunfeiyun.agmp.iotm.web.service;
+
+
+import com.yunfeiyun.agmp.iot.common.model.cmd.CmdModel;
+
+/**
+ * 指令执行Service接口
+ *
+ * @author 杨晓辉
+ * @date 2024-01-04
+ */
+public interface IIotCmdlogService
+{
+    /**
+     * 新增指令执行日志
+     *
+     * @return 结果
+     */
+    public int insertIotCmdloginsertIotCmdlog(CmdModel cmdModel);
+}

src/main/java/com/yunfeiyun/agmp/iotm/web/service/IIotCmdtaskService.java

@@ -0,0 +1,68 @@
+package com.yunfeiyun.agmp.iotm.web.service;
+
+
+import com.yunfeiyun.agmp.iot.common.domain.IotCmdtask;
+import com.yunfeiyun.agmp.iot.common.model.cmd.CmdGroupModel;
+
+import java.util.List;
+
+/**
+ * 设备指令任务Service接口
+ *
+ * @author 杨晓辉
+ * @date 2024-01-04
+ */
+public interface IIotCmdtaskService {
+    /**
+     * 查询设备指令任务
+     *
+     * @param id 设备指令任务主键
+     * @return 设备指令任务
+     */
+    public IotCmdtask selectIotCmdtaskById(Long id);
+
+    /**
+     * 查询设备指令任务列表
+     *
+     * @param iotCmdtask 设备指令任务
+     * @return 设备指令任务集合
+     */
+    public List<IotCmdtask> selectIotCmdtaskList(IotCmdtask iotCmdtask);
+
+    /**
+     * 新增设备指令任务
+     *
+     * @param iotCmdtask 设备指令任务
+     * @return 结果
+     */
+    public int insertIotCmdtask(IotCmdtask iotCmdtask);
+
+    /**
+     * 修改设备指令任务
+     *
+     * @param iotCmdtask 设备指令任务
+     * @return 结果
+     */
+    public int updateIotCmdtask(IotCmdtask iotCmdtask);
+
+    /**
+     * 批量删除设备指令任务
+     *
+     * @param ids 需要删除的设备指令任务主键集合
+     * @return 结果
+     */
+    public int deleteIotCmdtaskByIds(Long[] ids);
+
+    /**
+     * 删除设备指令任务信息
+     *
+     * @param id 设备指令任务主键
+     * @return 结果
+     */
+    public int deleteIotCmdtaskById(Long id);
+
+    void handInternalCmd(CmdGroupModel cmdGroupModel);
+
+    IotCmdtask selectIotCmdtaskByCtBid(String taskId);
+
+}

src/main/java/com/yunfeiyun/agmp/iotm/web/service/IIotDeviceService.java

@@ -1,8 +1,11 @@
 package com.yunfeiyun.agmp.iotm.web.service;
 
 import com.yunfeiyun.agmp.iot.common.domain.IotDevice;
+import com.yunfeiyun.agmp.iotm.device.common.domin.IotDeviceBaseCtlReqVo;
 import com.yunfeiyun.agmp.iotm.web.domain.reqvo.IotDeviceAddReqVo;
 
+import com.yunfeiyun.agmp.iotm.device.common.domin.IotDeviceBaseListReqVo;
+
 import java.util.List;
 
 /**
@@ -30,12 +33,6 @@ public interface IIotDeviceService
      * @return 设备基础集合
      */
     public List<IotDevice> selectIotDeviceList(IotDevice iotDevice);
-
-    /**
-     * 查询设备详情列表,此接口为通用接口，用于查询单一设备类型的详细数据,如需要查询多设备类型的数据在一个接口内,单独写接口
-     * */
-    public <T> List<T> selectIotDeviceDetailResVoList(IotDevice iotDevice);
-
     /**
      * 新增设备基础
      * 
@@ -51,13 +48,10 @@ public interface IIotDeviceService
      * @return 结果
      */
     public int updateIotDevice(IotDevice iotDevice);
-
-
-
     /**
      * 删除设备基础信息
      * 
-     * @param id 设备基础主键
+     * @param devBid 设备基础主键
      * @return 结果
      */
     public int deleteIotDeviceByDevBid(String devBid);

src/main/java/com/yunfeiyun/agmp/iotm/web/service/impl/IotCmdexecServiceImpl.java

@@ -0,0 +1,101 @@
+package com.yunfeiyun.agmp.iotm.web.service.impl;
+
+import com.yunfeiyun.agmp.iot.common.domain.IotCmdexec;
+
+import com.yunfeiyun.agmp.iotm.web.mapper.IotCmdexecMapper;
+import com.yunfeiyun.agmp.iotm.web.service.IIotCmdexecService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+
+/**
+ * 指令执行Service业务层处理
+ *
+ * @author 杨晓辉
+ * @date 2024-01-04
+ */
+@Service
+public class IotCmdexecServiceImpl implements IIotCmdexecService
+{
+    @Autowired
+    private IotCmdexecMapper iotCmdexecMapper;
+
+    /**
+     * 查询指令执行
+     *
+     * @param id 指令执行主键
+     * @return 指令执行
+     */
+    @Override
+    public IotCmdexec selectIotCmdexecById(Long id)
+    {
+        return iotCmdexecMapper.selectIotCmdexecById(id);
+    }
+
+    /**
+     * 查询指令执行列表
+     *
+     * @param iotCmdexec 指令执行
+     * @return 指令执行
+     */
+    @Override
+    public List<IotCmdexec> selectIotCmdexecList(IotCmdexec iotCmdexec)
+    {
+        return iotCmdexecMapper.selectIotCmdexecList(iotCmdexec);
+    }
+
+    /**
+     * 新增指令执行
+     *
+     * @param iotCmdexec 指令执行
+     * @return 结果
+     */
+    @Override
+    public int insertIotCmdexec(IotCmdexec iotCmdexec)
+    {
+        return iotCmdexecMapper.insertIotCmdexec(iotCmdexec);
+    }
+
+    /**
+     * 修改指令执行
+     *
+     * @param iotCmdexec 指令执行
+     * @return 结果
+     */
+    @Override
+    public int updateIotCmdexec(IotCmdexec iotCmdexec)
+    {
+        return iotCmdexecMapper.updateIotCmdexec(iotCmdexec);
+    }
+
+    /**
+     * 批量删除指令执行
+     *
+     * @param ids 需要删除的指令执行主键
+     * @return 结果
+     */
+    @Override
+    public int deleteIotCmdexecByIds(Long[] ids)
+    {
+        return iotCmdexecMapper.deleteIotCmdexecByIds(ids);
+    }
+
+    /**
+     * 删除指令执行信息
+     *
+     * @param id 指令执行主键
+     * @return 结果
+     */
+    @Override
+    public int deleteIotCmdexecById(Long id)
+    {
+        return iotCmdexecMapper.deleteIotCmdexecById(id);
+    }
+
+    @Override
+    public List<IotCmdexec> selectCmdExeByCeBids(String[] ids) {
+        return iotCmdexecMapper.selectCmdExeByCeBids(ids);
+    }
+}

src/main/java/com/yunfeiyun/agmp/iotm/web/service/impl/IotCmdlogServiceImpl.java

@@ -0,0 +1,56 @@
+package com.yunfeiyun.agmp.iotm.web.service.impl;
+
+import com.yunfeiyun.agmp.common.utils.DateUtils;
+import com.yunfeiyun.agmp.iot.common.domain.IotBaseEntity;
+import com.yunfeiyun.agmp.iot.common.domain.IotCmdlog;
+import com.yunfeiyun.agmp.iot.common.domain.IotDevice;
+import com.yunfeiyun.agmp.iot.common.model.cmd.CmdModel;
+import com.yunfeiyun.agmp.iot.common.service.MongoService;
+
+import com.yunfeiyun.agmp.iotm.web.service.IIotCmdlogService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+
+/**
+ * 指令执行Service业务层处理
+ *
+ * @author 杨晓辉
+ * @date 2024-01-04
+ */
+@Service
+public class IotCmdlogServiceImpl implements IIotCmdlogService
+{
+    @Autowired
+    private MongoService<IotBaseEntity> mongoService;
+
+    /**
+     * 新增指令执行日志
+     *
+     * @return 结果
+     */
+    @Override
+    public int insertIotCmdloginsertIotCmdlog(CmdModel cmdModel) {
+        IotDevice iotDevice = cmdModel.getIotDevice();
+        String dateTimeStr = DateUtils.dateTimeNow();
+
+        IotCmdlog iotCmdlog = new IotCmdlog();
+        iotCmdlog.setClogBid(iotCmdlog.getUUId());
+        iotCmdlog.setCId(iotDevice.getTid());
+        iotCmdlog.setCtBid(cmdModel.getCtBid());
+        iotCmdlog.setCeBid(cmdModel.getCeBid());
+        iotCmdlog.setDevBid(iotDevice.getDevBid());
+        iotCmdlog.setClogInstruct(cmdModel.getCmdDistribution().getJsons());
+        iotCmdlog.setClogSendresult(cmdModel.getClogSendresult());
+        iotCmdlog.setClogDesc(cmdModel.getClogDesc());
+        iotCmdlog.setClogValidresult(cmdModel.getClogValidresult());
+        iotCmdlog.setClogModifieddate(dateTimeStr);
+        iotCmdlog.setClogStartddate(dateTimeStr);
+        iotCmdlog.setClogCompletedate(dateTimeStr);
+        iotCmdlog.setClogCreateddate(dateTimeStr);
+        iotCmdlog.setClogDelstatus("0");
+
+        mongoService.saveOne(iotCmdlog);
+        return 0;
+    }
+}

src/main/java/com/yunfeiyun/agmp/iotm/web/service/impl/IotCmdtaskServiceImpl.java

@@ -0,0 +1,142 @@
+package com.yunfeiyun.agmp.iotm.web.service.impl;
+
+import com.yunfeiyun.agmp.common.utils.DateUtils;
+import com.yunfeiyun.agmp.common.utils.JSONUtils;
+import com.yunfeiyun.agmp.common.utils.SecurityUtils;
+import com.yunfeiyun.agmp.common.utils.StringUtils;
+import com.yunfeiyun.agmp.iot.common.constant.cmd.CmdgroupStatus;
+
+import com.yunfeiyun.agmp.iot.common.domain.IotCmdtask;
+import com.yunfeiyun.agmp.iot.common.model.cmd.CmdGroupModel;
+import com.yunfeiyun.agmp.iot.common.util.tmn.CustomerIdUtil;
+
+import com.yunfeiyun.agmp.iotm.mq.service.SendToIotsMsgService;
+import com.yunfeiyun.agmp.iotm.web.mapper.IotCmdtaskMapper;
+import com.yunfeiyun.agmp.iotm.web.service.IIotCmdtaskService;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import javax.annotation.Resource;
+import java.util.List;
+
+
+/**
+ * 设备指令任务Service业务层处理
+ *
+ * @author 杨晓辉
+ * @date 2024-01-04
+ */
+@Slf4j
+@Service
+public class IotCmdtaskServiceImpl implements IIotCmdtaskService {
+    @Autowired
+    private IotCmdtaskMapper iotCmdtaskMapper;
+    @Resource
+    private SendToIotsMsgService sendToIotsMsgService;
+
+    /**
+     * 查询设备指令任务
+     *
+     * @param id 设备指令任务主键
+     * @return 设备指令任务
+     */
+    @Override
+    public IotCmdtask selectIotCmdtaskById(Long id) {
+        return iotCmdtaskMapper.selectIotCmdtaskById(id);
+    }
+
+    /**
+     * 查询设备指令任务列表
+     *
+     * @param iotCmdtask 设备指令任务
+     * @return 设备指令任务
+     */
+    @Override
+    public List<IotCmdtask> selectIotCmdtaskList(IotCmdtask iotCmdtask) {
+        return iotCmdtaskMapper.selectIotCmdtaskList(iotCmdtask);
+    }
+
+    /**
+     * 新增设备指令任务
+     *
+     * @param iotCmdtask 设备指令任务
+     * @return 结果
+     */
+    @Override
+    public int insertIotCmdtask(IotCmdtask iotCmdtask) {
+        iotCmdtask.setCtDelstatus("0");
+        return iotCmdtaskMapper.insertIotCmdtask(iotCmdtask);
+    }
+
+    /**
+     * 修改设备指令任务
+     *
+     * @param iotCmdtask 设备指令任务
+     * @return 结果
+     */
+    @Override
+    public int updateIotCmdtask(IotCmdtask iotCmdtask) {
+        return iotCmdtaskMapper.updateIotCmdtask(iotCmdtask);
+    }
+
+    /**
+     * 批量删除设备指令任务
+     *
+     * @param ids 需要删除的设备指令任务主键
+     * @return 结果
+     */
+    @Override
+    public int deleteIotCmdtaskByIds(Long[] ids) {
+        return iotCmdtaskMapper.deleteIotCmdtaskByIds(ids);
+    }
+
+    /**
+     * 删除设备指令任务信息
+     *
+     * @param id 设备指令任务主键
+     * @return 结果
+     */
+    @Override
+    public int deleteIotCmdtaskById(Long id) {
+        return iotCmdtaskMapper.deleteIotCmdtaskById(id);
+    }
+
+    @Override
+    public void handInternalCmd(CmdGroupModel cmdGroupModel) {
+        log.info("【处理指令集】1{}", cmdGroupModel);
+        // 根据CmdGroupModel创建task任务
+        IotCmdtask iotCmdtask = new IotCmdtask();
+        iotCmdtask.setCId(CustomerIdUtil.getCustomerId());
+        iotCmdtask.setCtBid(iotCmdtask.getUUId());
+        iotCmdtask.setCtStatus(CmdgroupStatus.CM_STATUS_RUNNING.getCode());
+        iotCmdtask.setCtStartddate(DateUtils.dateTimeNow());
+        iotCmdtask.setCtRequestid(cmdGroupModel.getRequestId());
+        iotCmdtask.setCtRequestSource("IOTM");
+        iotCmdtask.setCtDescribe(cmdGroupModel.getTaskDesc());
+        String jstrCmdGroup = JSONUtils.toJSONString(cmdGroupModel);
+        //log.info("【处理指令集】2{}", jstrCmdGroup);
+        iotCmdtask.setCtRequestParam(jstrCmdGroup);
+        iotCmdtask.setCtReceiptaddr(cmdGroupModel.getReceiptAddr());
+        cmdGroupModel.setTaskUuid(iotCmdtask.getCtBid());
+        // 补充新的参数
+        iotCmdtask.setCtCreatorname(SecurityUtils.getUsername());
+        iotCmdtask.setCtDevcode(cmdGroupModel.getDevCode());
+        iotCmdtask.setCtBiztitle(cmdGroupModel.getCtBiztitle());
+        iotCmdtask.setCtBiztype(cmdGroupModel.getCtBiztype());
+        iotCmdtask.setCtDevtype(cmdGroupModel.getCtDevtype());
+        iotCmdtask.setCtParam(cmdGroupModel.getCtParam());
+        // 只有是指令日志的才标记，有些地方混用了这张表
+        if (!StringUtils.isEmpty(cmdGroupModel.getCtBiztype())) {
+            iotCmdtask.setCtLogtype(1);
+        }
+        this.insertIotCmdtask(iotCmdtask);
+        sendToIotsMsgService.sendCmdMsg( cmdGroupModel);
+    }
+
+
+    @Override
+    public IotCmdtask selectIotCmdtaskByCtBid(String taskId) {
+        return iotCmdtaskMapper.selectIotCmdtaskByCtBid(taskId);
+    }
+}

src/main/java/com/yunfeiyun/agmp/iotm/web/service/impl/IotDeviceServiceImpl.java

@@ -3,6 +3,7 @@ package com.yunfeiyun.agmp.iotm.web.service.impl;
 import java.util.List;
 import java.util.Map;
 
+import com.baomidou.mybatisplus.core.toolkit.ObjectUtils;
 import com.yunfeiyun.agmp.common.constant.ErrorCode;
 import com.yunfeiyun.agmp.common.utils.DateUtils;
 import com.yunfeiyun.agmp.common.utils.SecurityUtils;
@@ -13,7 +14,9 @@ import com.yunfeiyun.agmp.iot.common.enums.IotDeviceDelStatusEnum;
 import com.yunfeiyun.agmp.iot.common.enums.IotDeviceStatusTypeEnum;
 import com.yunfeiyun.agmp.iot.common.exception.IotBizException;
 import com.yunfeiyun.agmp.iot.common.service.TypeCacheService;
-import com.yunfeiyun.agmp.iotm.common.service.IotDeviceBaseService;
+import com.yunfeiyun.agmp.iotm.device.common.domin.IotDeviceBaseCtlReqVo;
+import com.yunfeiyun.agmp.iotm.device.common.domin.IotDeviceBaseListReqVo;
+import com.yunfeiyun.agmp.iotm.device.common.service.IotDeviceBaseService;
 
 import com.yunfeiyun.agmp.iotm.web.domain.reqvo.IotDeviceAddReqVo;
 import com.yunfeiyun.agmp.iotm.web.mapper.IotDeviceMapper;
@@ -23,6 +26,7 @@ import com.yunfeiyun.agmp.iotm.mq.service.SendToTosMsgService;
 
 import com.yunfeiyun.agmp.iotm.mq.service.SendToIotsMsgService;
 import com.yunfeiyun.agmp.iotm.web.service.IIotDeviceconnService;
+import org.springframework.beans.BeanUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
@@ -43,8 +47,7 @@ public class IotDeviceServiceImpl implements IIotDeviceService
     private SendToTosMsgService sendToTosMsgService;
     @Resource
     private SendToIotsMsgService sendToIotsMsgService;
-//    @Resource
-    private Map<String, IotDeviceBaseService> iotDeviceBaseServiceMap;
+
     @Resource
     private TypeCacheService typeCacheService;
 
@@ -126,12 +129,6 @@ public class IotDeviceServiceImpl implements IIotDeviceService
         return iotDeviceMapper.selectIotDeviceList(iotDevice);
     }
 
-    @Override
-    public <T> List<T> selectIotDeviceDetailResVoList(IotDevice iotDevice) {
-        String serviceName = typeCacheService.getServiceNameByDevTypeBid(iotDevice.getDevtypeBid());
-        IotDeviceBaseService iotDeviceBaseService = iotDeviceBaseServiceMap.get(serviceName);
-        return iotDeviceBaseService.list(iotDevice);
-    }
 
     /**
      * 新增设备基础