添加设备相关信息

common-lib/src/main/java/com/mortals/xhx/common/pdu/device/DeviceReq.java

 package com.mortals.xhx.common.pdu.device;
 
-import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
 import lombok.Data;
 
 import java.io.Serializable;

sample-form-manager/db/add.sql

+-- ----------------------------
+2023-06-21
+-- ----------------------------
+ALTER TABLE mortals_xhx_device
+    ADD COLUMN `deviceFirmId` bigint(20) DEFAULT NULL COMMENT '设备生产厂商ID' AFTER siteName;
+ALTER TABLE mortals_xhx_device
+    ADD COLUMN `deviceFirmname` varchar(200) DEFAULT NULL COMMENT '设备生产厂商名称' AFTER deviceFirmId;
+
+ALTER TABLE mortals_xhx_device
+    ADD COLUMN `ip` varchar(64) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL COMMENT '设备访问ip' AFTER deviceFirmname;
+
+ALTER TABLE mortals_xhx_device
+    ADD COLUMN `port` varchar(64) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL COMMENT '端口' AFTER ip;
+ALTER TABLE mortals_xhx_device
+    ADD COLUMN `enabled` tinyint(2) DEFAULT NULL COMMENT '启用状态 (0.停止，1.启用)' AFTER port;
+
+ALTER TABLE mortals_xhx_device
+    ADD COLUMN `deviceRemark` varchar(256) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL COMMENT '备注' AFTER enabled;
+ALTER TABLE mortals_xhx_device
+    ADD COLUMN `onlineTime` datetime DEFAULT NULL COMMENT '最近上线时间' AFTER deviceRemark;
+ALTER TABLE mortals_xhx_device
+    ADD COLUMN `offlineTime` datetime DEFAULT NULL COMMENT '最近离线时间' AFTER onlineTime;
\ No newline at end of file

sample-form-manager/src/main/java/com/mortals/xhx/base/framework/aspect/OperlogAspect.java

@@ -4,8 +4,10 @@ import java.util.Date;
 
 import javax.servlet.http.HttpServletRequest;
 
+import cn.hutool.core.util.StrUtil;
 import com.mortals.framework.model.OperateLogPdu;
 import com.mortals.framework.service.IMessageProduceService;
+import com.mortals.xhx.common.code.OperTypeEnum;
 import com.mortals.xhx.system.MessageProducer;
 import org.aspectj.lang.JoinPoint;
 import org.aspectj.lang.annotation.AfterReturning;
@@ -28,7 +30,7 @@ import com.mortals.xhx.base.system.oper.service.OperLogService;
  * 操作日志记录
  */
 @Component
-public class OperlogAspect extends FileLogServiceImpl   implements ILogService {
+public class OperlogAspect extends FileLogServiceImpl implements ILogService {
 
     private final static Logger logger = LoggerFactory.getLogger(OperlogAspect.class);
 
@@ -39,11 +41,19 @@ public class OperlogAspect extends FileLogServiceImpl   implements ILogService {
 
     @Override
     public void doHandlerLog(String platformMark, Long userId, String userName, String loginName, String requestUrl,
-            String content, String ip, Date logDate) {
+                             String content, String ip, Date logDate) {
         super.doHandlerLog(platformMark, userId, userName, loginName, requestUrl, content, ip, logDate);
-        if(ObjectUtils.isEmpty(userId)) return;
         operLogService.insertOperLog(ip, requestUrl, userId, userName, loginName, content);
 
+        int operType = OperTypeEnum.OTHER.getValue();
+        //判断内容包含
+        if (StrUtil.contains(content, "查询") || StrUtil.contains(content, "查看")) {
+            operType = OperTypeEnum.SEARCH.getValue();
+        } else if (StrUtil.contains(content, "保存") || StrUtil.contains(content, "新增") || StrUtil.contains(content, "修改")) {
+            operType = OperTypeEnum.SAVE.getValue();
+        } else if (StrUtil.contains(content, "删除")) {
+            operType = OperTypeEnum.DELETE.getValue();
+        }
         OperateLogPdu operateLogPdu = new OperateLogPdu();
         operateLogPdu.initAttrValue();
         operateLogPdu.setIp(ip);
@@ -54,17 +64,13 @@ public class OperlogAspect extends FileLogServiceImpl   implements ILogService {
         operateLogPdu.setPlatformMark(platformMark);
         operateLogPdu.setLogDate(logDate);
         operateLogPdu.setContent(content);
-        operateLogPdu.setOperType(1);
+        operateLogPdu.setOperType(operType);
         messageProducer.syncOperSend(operateLogPdu);
     }
 
     @Override
     public void doHandlerLog(String platformMark, String loginName, String requestUrl, String content, String ip) {
-        // operLogService.insertOperLog(ip, requestUrl, null, "", loginName,
-        // content);
         this.doHandlerLog(platformMark, null, "", loginName, requestUrl, content, ip, new Date());
-
-
     }
 
     @Pointcut("execution(public  * com.mortals.xhx..*Controller.*(..))")
@@ -79,7 +85,6 @@ public class OperlogAspect extends FileLogServiceImpl   implements ILogService {
         // url
         logger.info("ip[{}]url[{}]", request.getRemoteAddr(), request.getRequestURL());
         // 参数第1和第2个参数为HttpServletRequest request, HttpServletResponse
-        // response
         if (joinPoint.getArgs().length > 2) {
             logger.info("args={}", joinPoint.getArgs()[2]);
         } else {

sample-form-manager/src/main/java/com/mortals/xhx/common/code/DeviceMethodEnum.java

+package com.mortals.xhx.common.code;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+/**
+* 设备请求方式，1：新增，2：修改，3：删除，4：激活，5：启用，6：停用
+*
+* @author zxfei
+*/
+public enum DeviceMethodEnum {
+    ADD(1, "新增"),
+    UPDATE(2, "修改"),
+    DEL(3, "删除"),
+    ACTIVE(4, "激活"),
+    ENABLED(5, "启用"),
+    STOP(6, "停用"),
+    ONLINE(7, "上线"),
+    OFFLINE(8, "下线")
+    ;
+    private Integer value;
+    private String desc;
+
+    DeviceMethodEnum(Integer value, String desc) {
+        this.value = value;
+        this.desc = desc;
+    }
+
+    public Integer getValue() {
+        return this.value;
+    }
+
+    public String getDesc() {
+        return this.desc;
+    }
+
+    public static DeviceMethodEnum getByValue(Integer value) {
+        for (DeviceMethodEnum deviceTypeEnum : DeviceMethodEnum.values()) {
+            if (deviceTypeEnum.getValue() == value) {
+                return deviceTypeEnum;
+            }
+        }
+        return null;
+    }
+
+    /**
+    * 获取Map集合
+    *
+    * @param eItem 不包含项
+    * @return
+    */
+    public static Map<String, String> getEnumMap(Integer... eItem) {
+        Map<String, String> resultMap = new LinkedHashMap<>();
+        for (DeviceMethodEnum item : DeviceMethodEnum.values()) {
+            try {
+                boolean hasE = false;
+                for (Integer e : eItem) {
+                    if (item.getValue() == e) {
+                        hasE = true;
+                        break;
+                    }
+                }
+                if (!hasE) {
+                    resultMap.put(item.getValue() + "", item.getDesc());
+                }
+            } catch (Exception ex) {
+
+            }
+        }
+        return resultMap;
+    }
+}
\ No newline at end of file

sample-form-manager/src/main/java/com/mortals/xhx/common/code/EnabledEnum.java

+package com.mortals.xhx.common.code;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+/**
+* 启用状态 (0.停止，1.启用)枚举类
+*
+* @author zxfei
+*/
+public enum EnabledEnum {
+    停止(0, "停止"),
+    启用(1, "启用");
+    private Integer value;
+    private String desc;
+
+    EnabledEnum(Integer value, String desc) {
+        this.value = value;
+        this.desc = desc;
+    }
+
+    public Integer getValue() {
+        return this.value;
+    }
+
+    public String getDesc() {
+        return this.desc;
+    }
+
+    public static EnabledEnum getByValue(Integer value) {
+        for (EnabledEnum enabledEnum : EnabledEnum.values()) {
+            if (enabledEnum.getValue() == value) {
+                return enabledEnum;
+            }
+        }
+        return null;
+    }
+
+    /**
+    * 获取Map集合
+    *
+    * @param eItem 不包含项
+    * @return
+    */
+    public static Map<String, String> getEnumMap(Integer... eItem) {
+        Map<String, String> resultMap = new LinkedHashMap<>();
+        for (EnabledEnum item : EnabledEnum.values()) {
+            try {
+                boolean hasE = false;
+                for (Integer e : eItem) {
+                    if (item.getValue() == e) {
+                        hasE = true;
+                        break;
+                    }
+                }
+                if (!hasE) {
+                    resultMap.put(item.getValue() + "", item.getDesc());
+                }
+            } catch (Exception ex) {
+
+            }
+        }
+        return resultMap;
+    }
+}
\ No newline at end of file

sample-form-manager/src/main/java/com/mortals/xhx/common/code/OperTypeEnum.java

@@ -3,20 +3,19 @@ package com.mortals.xhx.common.code;
 import java.util.HashMap;
 import java.util.Map;
 
-/**
- * Created by chendilin on 2018/3/7.
- */
+
 public enum OperTypeEnum {
 
-    SAVE(0,"添加"),
-    UPDATE(1,"更新"),
-    DELETE(2,"删除"),
-    OTHER(-1,"其它");
+    SAVE(0, "添加"),
+    UPDATE(1, "更新"),
+    DELETE(2, "删除"),
+    SEARCH(3, "查询"),
+    OTHER(-1, "其它");
 
     private int value;
     private String msg;
 
-    private OperTypeEnum(int value,String msg) {
+    private OperTypeEnum(int value, String msg) {
         this.value = value;
         this.msg = msg;
     }
@@ -25,11 +24,11 @@ public enum OperTypeEnum {
         return this.value;
     }
 
-    public static Map<String,String> getEnumMap(){
-        Map<String,String> resultMap = new HashMap<>();
-        OperTypeEnum[] operTypeEnum =  OperTypeEnum.values();
+    public static Map<String, String> getEnumMap() {
+        Map<String, String> resultMap = new HashMap<>();
+        OperTypeEnum[] operTypeEnum = OperTypeEnum.values();
         for (OperTypeEnum typeEnum : operTypeEnum) {
-            resultMap.put(String.valueOf(typeEnum.value),typeEnum.msg);
+            resultMap.put(String.valueOf(typeEnum.value), typeEnum.msg);
         }
         return resultMap;
     }

sample-form-manager/src/main/java/com/mortals/xhx/module/device/model/DeviceEntity.java

 package com.mortals.xhx.module.device.model;
-
+import java.util.Date;
 import java.util.List;
 import java.util.ArrayList;
 import com.fasterxml.jackson.annotation.JsonFormat;
 import com.mortals.framework.annotation.Excel;
 import com.mortals.framework.model.BaseEntityLong;
 import com.mortals.xhx.module.device.model.vo.DeviceVo;
+import lombok.Data;
 /**
-* 设备实体对象
-*
-* @author zxfei
-* @date 2023-02-25
-*/
-
+ * 设备实体对象
+ *
+ * @author zxfei
+ * @date 2023-06-21
+ */
+@Data
 public class DeviceEntity extends DeviceVo {
     private static final long serialVersionUID = 1L;
 
     /**
-    * 设备id
-    */
+     * 设备id
+     */
     private Long deviceId;
     /**
-    * 设备名称
-    */
+     * 设备名称
+     */
     private String deviceName;
     /**
-    * 设备编码
-    */
+     * 设备编码
+     */
     private String deviceCode;
     /**
-    * 设备的MAC地址
-    */
+     * 设备的MAC地址
+     */
     private String deviceMac;
     /**
-    * 站点Id
-    */
+     * 站点Id
+     */
     private Long siteId;
     /**
-    * 站点编号，来源基础服务平台
-    */
+     * 站点编号，来源基础服务平台
+     */
     private String siteCode;
     /**
-    * 站点名称
-    */
+     * 站点名称
+     */
     private String siteName;
     /**
-    * 产品编码
-    */
+     * 产品编码
+     */
     private String productCode;
     /**
-    * 产品名称
-    */
+     * 产品名称
+     */
     private String productName;
     /**
-    * 设备来源(0.子设备，1.网关设备，2.直连设备)
-    */
+     * 设备来源(0.子设备，1.网关设备，2.直连设备)
+     */
     private Integer deviceSrc;
     /**
-    * 经度
-    */
+     * 经度
+     */
     private String lon;
     /**
-    * 纬度
-    */
+     * 纬度
+     */
     private String lati;
     /**
-    * 负责人
-    */
+     * 负责人
+     */
     private String leadingOfficial;
     /**
-    * 联系电话
-    */
+     * 联系电话
+     */
     private String leadingOfficialTelephone;
     /**
-    * 设备状态 (0.未激活，1.离线,2.在线)
-    */
+     * 设备状态 (0.未激活，1.离线,2.在线)
+     */
     private Integer deviceStatus;
     /**
-    * 备注
-    */
+     * 备注
+     */
     private String deviceRemark;
     /**
-    * 设备来源(0.旧设备，1.新设备)
-    */
+     * 设备来源(0.旧设备，1.新设备)
+     */
     private Integer source;
-
-
-
-    public DeviceEntity(){}
-    /**
-    * 获取 设备id
-    * @return Long
-    */
-    public Long getDeviceId(){
-        return deviceId;
-    }
-    /**
-    * 设置 设备id
-    * @param deviceId
-    */
-    public void setDeviceId(Long deviceId){
-        this.deviceId = deviceId;
-    }
-    /**
-    * 获取 设备名称
-    * @return String
-    */
-    public String getDeviceName(){
-        return deviceName;
-    }
-    /**
-    * 设置 设备名称
-    * @param deviceName
-    */
-    public void setDeviceName(String deviceName){
-        this.deviceName = deviceName;
-    }
-    /**
-    * 获取 设备编码
-    * @return String
-    */
-    public String getDeviceCode(){
-        return deviceCode;
-    }
-    /**
-    * 设置 设备编码
-    * @param deviceCode
-    */
-    public void setDeviceCode(String deviceCode){
-        this.deviceCode = deviceCode;
-    }
-    /**
-    * 获取 设备的MAC地址
-    * @return String
-    */
-    public String getDeviceMac(){
-        return deviceMac;
-    }
-    /**
-    * 设置 设备的MAC地址
-    * @param deviceMac
-    */
-    public void setDeviceMac(String deviceMac){
-        this.deviceMac = deviceMac;
-    }
-    /**
-    * 获取 站点Id
-    * @return Long
-    */
-    public Long getSiteId(){
-        return siteId;
-    }
-    /**
-    * 设置 站点Id
-    * @param siteId
-    */
-    public void setSiteId(Long siteId){
-        this.siteId = siteId;
-    }
-    /**
-    * 获取 站点编号，来源基础服务平台
-    * @return String
-    */
-    public String getSiteCode(){
-        return siteCode;
-    }
-    /**
-    * 设置 站点编号，来源基础服务平台
-    * @param siteCode
-    */
-    public void setSiteCode(String siteCode){
-        this.siteCode = siteCode;
-    }
-    /**
-    * 获取 站点名称
-    * @return String
-    */
-    public String getSiteName(){
-        return siteName;
-    }
     /**
-    * 设置 站点名称
-    * @param siteName
-    */
-    public void setSiteName(String siteName){
-        this.siteName = siteName;
-    }
+     * 设备生产厂商ID
+     */
+    private Long deviceFirmId;
     /**
-    * 获取 产品编码
-    * @return String
-    */
-    public String getProductCode(){
-        return productCode;
-    }
-    /**
-    * 设置 产品编码
-    * @param productCode
-    */
-    public void setProductCode(String productCode){
-        this.productCode = productCode;
-    }
+     * 设备生产厂商名称
+     */
+    private String deviceFirmname;
     /**
-    * 获取 产品名称
-    * @return String
-    */
-    public String getProductName(){
-        return productName;
-    }
+     * 设备访问ip
+     */
+    private String ip;
     /**
-    * 设置 产品名称
-    * @param productName
-    */
-    public void setProductName(String productName){
-        this.productName = productName;
-    }
+     * 端口
+     */
+    private String port;
     /**
-    * 获取 设备来源(0.子设备，1.网关设备，2.直连设备)
-    * @return Integer
-    */
-    public Integer getDeviceSrc(){
-        return deviceSrc;
-    }
+     * 启用状态 (0.停止，1.启用)
+     */
+    private Integer enabled;
     /**
-    * 设置 设备来源(0.子设备，1.网关设备，2.直连设备)
-    * @param deviceSrc
-    */
-    public void setDeviceSrc(Integer deviceSrc){
-        this.deviceSrc = deviceSrc;
-    }
+     * 最近上线时间
+     */
+    private Date onlineTime;
     /**
-    * 获取 经度
-    * @return String
-    */
-    public String getLon(){
-        return lon;
-    }
-    /**
-    * 设置 经度
-    * @param lon
-    */
-    public void setLon(String lon){
-        this.lon = lon;
-    }
-    /**
-    * 获取 纬度
-    * @return String
-    */
-    public String getLati(){
-        return lati;
-    }
-    /**
-    * 设置 纬度
-    * @param lati
-    */
-    public void setLati(String lati){
-        this.lati = lati;
-    }
-    /**
-    * 获取 负责人
-    * @return String
-    */
-    public String getLeadingOfficial(){
-        return leadingOfficial;
-    }
-    /**
-    * 设置 负责人
-    * @param leadingOfficial
-    */
-    public void setLeadingOfficial(String leadingOfficial){
-        this.leadingOfficial = leadingOfficial;
-    }
-    /**
-    * 获取 联系电话
-    * @return String
-    */
-    public String getLeadingOfficialTelephone(){
-        return leadingOfficialTelephone;
-    }
-    /**
-    * 设置 联系电话
-    * @param leadingOfficialTelephone
-    */
-    public void setLeadingOfficialTelephone(String leadingOfficialTelephone){
-        this.leadingOfficialTelephone = leadingOfficialTelephone;
-    }
-    /**
-    * 获取 设备状态 (0.未激活，1.离线,2.在线)
-    * @return Integer
-    */
-    public Integer getDeviceStatus(){
-        return deviceStatus;
-    }
-    /**
-    * 设置 设备状态 (0.未激活，1.离线,2.在线)
-    * @param deviceStatus
-    */
-    public void setDeviceStatus(Integer deviceStatus){
-        this.deviceStatus = deviceStatus;
-    }
-    /**
-    * 获取 备注
-    * @return String
-    */
-    public String getDeviceRemark(){
-        return deviceRemark;
-    }
-    /**
-    * 设置 备注
-    * @param deviceRemark
-    */
-    public void setDeviceRemark(String deviceRemark){
-        this.deviceRemark = deviceRemark;
-    }
-    /**
-    * 获取 设备来源(0.旧设备，1.新设备)
-    * @return Integer
-    */
-    public Integer getSource(){
-        return source;
-    }
-    /**
-    * 设置 设备来源(0.旧设备，1.新设备)
-    * @param source
-    */
-    public void setSource(Integer source){
-        this.source = source;
-    }
-
-
-
-
+     * 最近离线时间
+     */
+    private Date offlineTime;
     @Override
     public int hashCode() {
-         return this.getId().hashCode();
+        return this.getId().hashCode();
     }
     @Override
     public boolean equals(Object obj) {
@@ -340,68 +123,60 @@ public class DeviceEntity extends DeviceVo {
         if (obj instanceof DeviceEntity) {
             DeviceEntity tmp = (DeviceEntity) obj;
             if (this.getId() == tmp.getId()) {
-                 return true;
+                return true;
             }
         }
         return false;
     }
 
-    public String toString(){
-        StringBuilder sb = new StringBuilder("");
-        sb.append(",deviceId:").append(getDeviceId());
-        sb.append(",deviceName:").append(getDeviceName());
-        sb.append(",deviceCode:").append(getDeviceCode());
-        sb.append(",deviceMac:").append(getDeviceMac());
-        sb.append(",siteId:").append(getSiteId());
-        sb.append(",siteCode:").append(getSiteCode());
-        sb.append(",siteName:").append(getSiteName());
-        sb.append(",productCode:").append(getProductCode());
-        sb.append(",productName:").append(getProductName());
-        sb.append(",deviceSrc:").append(getDeviceSrc());
-        sb.append(",lon:").append(getLon());
-        sb.append(",lati:").append(getLati());
-        sb.append(",leadingOfficial:").append(getLeadingOfficial());
-        sb.append(",leadingOfficialTelephone:").append(getLeadingOfficialTelephone());
-        sb.append(",deviceStatus:").append(getDeviceStatus());
-        sb.append(",deviceRemark:").append(getDeviceRemark());
-        sb.append(",source:").append(getSource());
-        return sb.toString();
-    }
-
     public void initAttrValue(){
 
-            this.deviceId = null;
+        this.deviceId = -1L;
+
+        this.deviceName = "";
+
+        this.deviceCode = "";
+
+        this.deviceMac = "";
+
+        this.siteId = -1L;
+
+        this.siteCode = "";
+
+        this.siteName = "";
+
+        this.productCode = "";
 
-            this.deviceName = null;
+        this.productName = "";
 
-            this.deviceCode = null;
+        this.deviceSrc = 2;
 
-            this.deviceMac = null;
+        this.lon = "";
 
-            this.siteId = null;
+        this.lati = "";
 
-            this.siteCode = null;
+        this.leadingOfficial = "";
 
-            this.siteName = null;
+        this.leadingOfficialTelephone = "";
 
-            this.productCode = null;
+        this.deviceStatus = 0;
 
-            this.productName = null;
+        this.deviceRemark = "";
 
-            this.deviceSrc = 2;
+        this.source = 1;
 
-            this.lon = null;
+        this.deviceFirmId = -1L;
 
-            this.lati = null;
+        this.deviceFirmname = "";
 
-            this.leadingOfficial = null;
+        this.ip = "";
 
-            this.leadingOfficialTelephone = null;
+        this.port = "";
 
-            this.deviceStatus = null;
+        this.enabled = 0;
 
-            this.deviceRemark = null;
+        this.onlineTime = null;
 
-            this.source = 1;
+        this.offlineTime = null;
     }
 }
\ No newline at end of file

sample-form-manager/src/main/java/com/mortals/xhx/module/device/model/DeviceQuery.java

 package com.mortals.xhx.module.device.model;
 
+import java.util.Date;
 import java.util.List;
 import com.mortals.xhx.module.device.model.DeviceEntity;
 /**
-* 设备查询对象
-*
-* @author zxfei
-* @date 2023-02-25
-*/
+ * 设备查询对象
+ *
+ * @author zxfei
+ * @date 2023-06-21
+ */
 public class DeviceQuery extends DeviceEntity {
     /** 开始 主键ID，主键，自增长 */
     private Long idStart;
@@ -201,6 +202,63 @@ public class DeviceQuery extends DeviceEntity {
     /** 结束 更新时间 */
     private String updateTimeEnd;
 
+    /** 开始 设备生产厂商ID */
+    private Long deviceFirmIdStart;
+
+    /** 结束 设备生产厂商ID */
+    private Long deviceFirmIdEnd;
+
+    /** 增加 设备生产厂商ID */
+    private Long deviceFirmIdIncrement;
+
+    /** 设备生产厂商ID列表 */
+    private List <Long> deviceFirmIdList;
+
+    /** 设备生产厂商ID排除列表 */
+    private List <Long> deviceFirmIdNotList;
+
+    /** 设备生产厂商名称 */
+    private List<String> deviceFirmnameList;
+
+    /** 设备生产厂商名称排除列表 */
+    private List <String> deviceFirmnameNotList;
+    /** 设备访问ip */
+    private List<String> ipList;
+
+    /** 设备访问ip排除列表 */
+    private List <String> ipNotList;
+    /** 端口 */
+    private List<String> portList;
+
+    /** 端口排除列表 */
+    private List <String> portNotList;
+    /** 开始 启用状态 (0.停止，1.启用) */
+    private Integer enabledStart;
+
+    /** 结束 启用状态 (0.停止，1.启用) */
+    private Integer enabledEnd;
+
+    /** 增加 启用状态 (0.停止，1.启用) */
+    private Integer enabledIncrement;
+
+    /** 启用状态 (0.停止，1.启用)列表 */
+    private List <Integer> enabledList;
+
+    /** 启用状态 (0.停止，1.启用)排除列表 */
+    private List <Integer> enabledNotList;
+
+    /** 开始 最近上线时间 */
+    private String onlineTimeStart;
+
+    /** 结束 最近上线时间 */
+    private String onlineTimeEnd;
+
+    /** 开始 最近离线时间 */
+    private String offlineTimeStart;
+
+    /** 结束 最近离线时间 */
+    private String offlineTimeEnd;
+
     /** OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4) */
     private List<DeviceQuery> orConditionList;
 
@@ -210,1791 +268,2280 @@ public class DeviceQuery extends DeviceEntity {
     public DeviceQuery(){}
 
     /**
-    * 获取 开始 主键ID，主键，自增长
-    * @return idStart
-    */
+     * 获取 开始 主键ID，主键，自增长
+     * @return idStart
+     */
     public Long getIdStart(){
         return this.idStart;
     }
 
     /**
-    * 设置 开始 主键ID，主键，自增长
-    * @param idStart
-    */
+     * 设置 开始 主键ID，主键，自增长
+     * @param idStart
+     */
     public void setIdStart(Long idStart){
         this.idStart = idStart;
     }
 
     /**
-    * 获取 结束 主键ID，主键，自增长
-    * @return $idEnd
-    */
+     * 获取 结束 主键ID，主键，自增长
+     * @return $idEnd
+     */
     public Long getIdEnd(){
         return this.idEnd;
     }
 
     /**
-    * 设置 结束 主键ID，主键，自增长
-    * @param idEnd
-    */
+     * 设置 结束 主键ID，主键，自增长
+     * @param idEnd
+     */
     public void setIdEnd(Long idEnd){
         this.idEnd = idEnd;
     }
 
     /**
-    * 获取 增加 主键ID，主键，自增长
-    * @return idIncrement
-    */
+     * 获取 增加 主键ID，主键，自增长
+     * @return idIncrement
+     */
     public Long getIdIncrement(){
         return this.idIncrement;
     }
 
     /**
-    * 设置 增加 主键ID，主键，自增长
-    * @param idIncrement
-    */
+     * 设置 增加 主键ID，主键，自增长
+     * @param idIncrement
+     */
     public void setIdIncrement(Long idIncrement){
         this.idIncrement = idIncrement;
     }
 
     /**
-    * 获取 主键ID，主键，自增长
-    * @return idList
-    */
+     * 获取 主键ID，主键，自增长
+     * @return idList
+     */
     public List<Long> getIdList(){
         return this.idList;
     }
 
     /**
-    * 设置 主键ID，主键，自增长
-    * @param idList
-    */
+     * 设置 主键ID，主键，自增长
+     * @param idList
+     */
     public void setIdList(List<Long> idList){
         this.idList = idList;
     }
 
     /**
-    * 获取 主键ID，主键，自增长
-    * @return idNotList
-    */
+     * 获取 主键ID，主键，自增长
+     * @return idNotList
+     */
     public List<Long> getIdNotList(){
         return this.idNotList;
     }
 
     /**
-    * 设置 主键ID，主键，自增长
-    * @param idNotList
-    */
+     * 设置 主键ID，主键，自增长
+     * @param idNotList
+     */
     public void setIdNotList(List<Long> idNotList){
         this.idNotList = idNotList;
     }
 
 
     /**
-    * 获取 开始 设备id
-    * @return deviceIdStart
-    */
+     * 获取 开始 设备id
+     * @return deviceIdStart
+     */
     public Long getDeviceIdStart(){
         return this.deviceIdStart;
     }
 
     /**
-    * 设置 开始 设备id
-    * @param deviceIdStart
-    */
+     * 设置 开始 设备id
+     * @param deviceIdStart
+     */
     public void setDeviceIdStart(Long deviceIdStart){
         this.deviceIdStart = deviceIdStart;
     }
 
     /**
-    * 获取 结束 设备id
-    * @return $deviceIdEnd
-    */
+     * 获取 结束 设备id
+     * @return $deviceIdEnd
+     */
     public Long getDeviceIdEnd(){
         return this.deviceIdEnd;
     }
 
     /**
-    * 设置 结束 设备id
-    * @param deviceIdEnd
-    */
+     * 设置 结束 设备id
+     * @param deviceIdEnd
+     */
     public void setDeviceIdEnd(Long deviceIdEnd){
         this.deviceIdEnd = deviceIdEnd;
     }
 
     /**
-    * 获取 增加 设备id
-    * @return deviceIdIncrement
-    */
+     * 获取 增加 设备id
+     * @return deviceIdIncrement
+     */
     public Long getDeviceIdIncrement(){
         return this.deviceIdIncrement;
     }
 
     /**
-    * 设置 增加 设备id
-    * @param deviceIdIncrement
-    */
+     * 设置 增加 设备id
+     * @param deviceIdIncrement
+     */
     public void setDeviceIdIncrement(Long deviceIdIncrement){
         this.deviceIdIncrement = deviceIdIncrement;
     }
 
     /**
-    * 获取 设备id
-    * @return deviceIdList
-    */
+     * 获取 设备id
+     * @return deviceIdList
+     */
     public List<Long> getDeviceIdList(){
         return this.deviceIdList;
     }
 
     /**
-    * 设置 设备id
-    * @param deviceIdList
-    */
+     * 设置 设备id
+     * @param deviceIdList
+     */
     public void setDeviceIdList(List<Long> deviceIdList){
         this.deviceIdList = deviceIdList;
     }
 
     /**
-    * 获取 设备id
-    * @return deviceIdNotList
-    */
+     * 获取 设备id
+     * @return deviceIdNotList
+     */
     public List<Long> getDeviceIdNotList(){
         return this.deviceIdNotList;
     }
 
     /**
-    * 设置 设备id
-    * @param deviceIdNotList
-    */
+     * 设置 设备id
+     * @param deviceIdNotList
+     */
     public void setDeviceIdNotList(List<Long> deviceIdNotList){
         this.deviceIdNotList = deviceIdNotList;
     }
 
 
     /**
-    * 获取 设备名称
-    * @return deviceNameList
-    */
+     * 获取 设备名称
+     * @return deviceNameList
+     */
     public List<String> getDeviceNameList(){
         return this.deviceNameList;
     }
 
     /**
-    * 设置 设备名称
-    * @param deviceNameList
-    */
+     * 设置 设备名称
+     * @param deviceNameList
+     */
     public void setDeviceNameList(List<String> deviceNameList){
         this.deviceNameList = deviceNameList;
     }
 
     /**
-    * 获取 设备名称
-    * @return deviceNameNotList
-    */
+     * 获取 设备名称
+     * @return deviceNameNotList
+     */
     public List<String> getDeviceNameNotList(){
         return this.deviceNameNotList;
     }
 
     /**
-    * 设置 设备名称
-    * @param deviceNameNotList
-    */
+     * 设置 设备名称
+     * @param deviceNameNotList
+     */
     public void setDeviceNameNotList(List<String> deviceNameNotList){
         this.deviceNameNotList = deviceNameNotList;
     }
 
     /**
-    * 获取 设备编码
-    * @return deviceCodeList
-    */
+     * 获取 设备编码
+     * @return deviceCodeList
+     */
     public List<String> getDeviceCodeList(){
         return this.deviceCodeList;
     }
 
     /**
-    * 设置 设备编码
-    * @param deviceCodeList
-    */
+     * 设置 设备编码
+     * @param deviceCodeList
+     */
     public void setDeviceCodeList(List<String> deviceCodeList){
         this.deviceCodeList = deviceCodeList;
     }
 
     /**
-    * 获取 设备编码
-    * @return deviceCodeNotList
-    */
+     * 获取 设备编码
+     * @return deviceCodeNotList
+     */
     public List<String> getDeviceCodeNotList(){
         return this.deviceCodeNotList;
     }
 
     /**
-    * 设置 设备编码
-    * @param deviceCodeNotList
-    */
+     * 设置 设备编码
+     * @param deviceCodeNotList
+     */
     public void setDeviceCodeNotList(List<String> deviceCodeNotList){
         this.deviceCodeNotList = deviceCodeNotList;
     }
 
     /**
-    * 获取 设备的MAC地址
-    * @return deviceMacList
-    */
+     * 获取 设备的MAC地址
+     * @return deviceMacList
+     */
     public List<String> getDeviceMacList(){
         return this.deviceMacList;
     }
 
     /**
-    * 设置 设备的MAC地址
-    * @param deviceMacList
-    */
+     * 设置 设备的MAC地址
+     * @param deviceMacList
+     */
     public void setDeviceMacList(List<String> deviceMacList){
         this.deviceMacList = deviceMacList;
     }
 
     /**
-    * 获取 设备的MAC地址
-    * @return deviceMacNotList
-    */
+     * 获取 设备的MAC地址
+     * @return deviceMacNotList
+     */
     public List<String> getDeviceMacNotList(){
         return this.deviceMacNotList;
     }
 
     /**
-    * 设置 设备的MAC地址
-    * @param deviceMacNotList
-    */
+     * 设置 设备的MAC地址
+     * @param deviceMacNotList
+     */
     public void setDeviceMacNotList(List<String> deviceMacNotList){
         this.deviceMacNotList = deviceMacNotList;
     }
 
     /**
-    * 获取 开始 站点Id
-    * @return siteIdStart
-    */
+     * 获取 开始 站点Id
+     * @return siteIdStart
+     */
     public Long getSiteIdStart(){
         return this.siteIdStart;
     }
 
     /**
-    * 设置 开始 站点Id
-    * @param siteIdStart
-    */
+     * 设置 开始 站点Id
+     * @param siteIdStart
+     */
     public void setSiteIdStart(Long siteIdStart){
         this.siteIdStart = siteIdStart;
     }
 
     /**
-    * 获取 结束 站点Id
-    * @return $siteIdEnd
-    */
+     * 获取 结束 站点Id
+     * @return $siteIdEnd
+     */
     public Long getSiteIdEnd(){
         return this.siteIdEnd;
     }
 
     /**
-    * 设置 结束 站点Id
-    * @param siteIdEnd
-    */
+     * 设置 结束 站点Id
+     * @param siteIdEnd
+     */
     public void setSiteIdEnd(Long siteIdEnd){
         this.siteIdEnd = siteIdEnd;
     }
 
     /**
-    * 获取 增加 站点Id
-    * @return siteIdIncrement
-    */
+     * 获取 增加 站点Id
+     * @return siteIdIncrement
+     */
     public Long getSiteIdIncrement(){
         return this.siteIdIncrement;
     }
 
     /**
-    * 设置 增加 站点Id
-    * @param siteIdIncrement
-    */
+     * 设置 增加 站点Id
+     * @param siteIdIncrement
+     */
     public void setSiteIdIncrement(Long siteIdIncrement){
         this.siteIdIncrement = siteIdIncrement;
     }
 
     /**
-    * 获取 站点Id
-    * @return siteIdList
-    */
+     * 获取 站点Id
+     * @return siteIdList
+     */
     public List<Long> getSiteIdList(){
         return this.siteIdList;
     }
 
     /**
-    * 设置 站点Id
-    * @param siteIdList
-    */
+     * 设置 站点Id
+     * @param siteIdList
+     */
     public void setSiteIdList(List<Long> siteIdList){
         this.siteIdList = siteIdList;
     }
 
     /**
-    * 获取 站点Id
-    * @return siteIdNotList
-    */
+     * 获取 站点Id
+     * @return siteIdNotList
+     */
     public List<Long> getSiteIdNotList(){
         return this.siteIdNotList;
     }
 
     /**
-    * 设置 站点Id
-    * @param siteIdNotList
-    */
+     * 设置 站点Id
+     * @param siteIdNotList
+     */
     public void setSiteIdNotList(List<Long> siteIdNotList){
         this.siteIdNotList = siteIdNotList;
     }
 
 
     /**
-    * 获取 站点编号，来源基础服务平台
-    * @return siteCodeList
-    */
+     * 获取 站点编号，来源基础服务平台
+     * @return siteCodeList
+     */
     public List<String> getSiteCodeList(){
         return this.siteCodeList;
     }
 
     /**
-    * 设置 站点编号，来源基础服务平台
-    * @param siteCodeList
-    */
+     * 设置 站点编号，来源基础服务平台
+     * @param siteCodeList
+     */
     public void setSiteCodeList(List<String> siteCodeList){
         this.siteCodeList = siteCodeList;
     }
 
     /**
-    * 获取 站点编号，来源基础服务平台
-    * @return siteCodeNotList
-    */
+     * 获取 站点编号，来源基础服务平台
+     * @return siteCodeNotList
+     */
     public List<String> getSiteCodeNotList(){
         return this.siteCodeNotList;
     }
 
     /**
-    * 设置 站点编号，来源基础服务平台
-    * @param siteCodeNotList
-    */
+     * 设置 站点编号，来源基础服务平台
+     * @param siteCodeNotList
+     */
     public void setSiteCodeNotList(List<String> siteCodeNotList){
         this.siteCodeNotList = siteCodeNotList;
     }
 
     /**
-    * 获取 站点名称
-    * @return siteNameList
-    */
+     * 获取 站点名称
+     * @return siteNameList
+     */
     public List<String> getSiteNameList(){
         return this.siteNameList;
     }
 
     /**
-    * 设置 站点名称
-    * @param siteNameList
-    */
+     * 设置 站点名称
+     * @param siteNameList
+     */
     public void setSiteNameList(List<String> siteNameList){
         this.siteNameList = siteNameList;
     }
 
     /**
-    * 获取 站点名称
-    * @return siteNameNotList
-    */
+     * 获取 站点名称
+     * @return siteNameNotList
+     */
     public List<String> getSiteNameNotList(){
         return this.siteNameNotList;
     }
 
     /**
-    * 设置 站点名称
-    * @param siteNameNotList
-    */
+     * 设置 站点名称
+     * @param siteNameNotList
+     */
     public void setSiteNameNotList(List<String> siteNameNotList){
         this.siteNameNotList = siteNameNotList;
     }
 
     /**
-    * 获取 产品编码
-    * @return productCodeList
-    */
+     * 获取 产品编码
+     * @return productCodeList
+     */
     public List<String> getProductCodeList(){
         return this.productCodeList;
     }
 
     /**
-    * 设置 产品编码
-    * @param productCodeList
-    */
+     * 设置 产品编码
+     * @param productCodeList
+     */
     public void setProductCodeList(List<String> productCodeList){
         this.productCodeList = productCodeList;
     }
 
     /**
-    * 获取 产品编码
-    * @return productCodeNotList
-    */
+     * 获取 产品编码
+     * @return productCodeNotList
+     */
     public List<String> getProductCodeNotList(){
         return this.productCodeNotList;
     }
 
     /**
-    * 设置 产品编码
-    * @param productCodeNotList
-    */
+     * 设置 产品编码
+     * @param productCodeNotList
+     */
     public void setProductCodeNotList(List<String> productCodeNotList){
         this.productCodeNotList = productCodeNotList;
     }
 
     /**
-    * 获取 产品名称
-    * @return productNameList
-    */
+     * 获取 产品名称
+     * @return productNameList
+     */
     public List<String> getProductNameList(){
         return this.productNameList;
     }
 
     /**
-    * 设置 产品名称
-    * @param productNameList
-    */
+     * 设置 产品名称
+     * @param productNameList
+     */
     public void setProductNameList(List<String> productNameList){
         this.productNameList = productNameList;
     }
 
     /**
-    * 获取 产品名称
-    * @return productNameNotList
-    */
+     * 获取 产品名称
+     * @return productNameNotList
+     */
     public List<String> getProductNameNotList(){
         return this.productNameNotList;
     }
 
     /**
-    * 设置 产品名称
-    * @param productNameNotList
-    */
+     * 设置 产品名称
+     * @param productNameNotList
+     */
     public void setProductNameNotList(List<String> productNameNotList){
         this.productNameNotList = productNameNotList;
     }
 
     /**
-    * 获取 开始 设备来源(0.子设备，1.网关设备，2.直连设备)
-    * @return deviceSrcStart
-    */
+     * 获取 开始 设备来源(0.子设备，1.网关设备，2.直连设备)
+     * @return deviceSrcStart
+     */
     public Integer getDeviceSrcStart(){
         return this.deviceSrcStart;
     }
 
     /**
-    * 设置 开始 设备来源(0.子设备，1.网关设备，2.直连设备)
-    * @param deviceSrcStart
-    */
+     * 设置 开始 设备来源(0.子设备，1.网关设备，2.直连设备)
+     * @param deviceSrcStart
+     */
     public void setDeviceSrcStart(Integer deviceSrcStart){
         this.deviceSrcStart = deviceSrcStart;
     }
 
     /**
-    * 获取 结束 设备来源(0.子设备，1.网关设备，2.直连设备)
-    * @return $deviceSrcEnd
-    */
+     * 获取 结束 设备来源(0.子设备，1.网关设备，2.直连设备)
+     * @return $deviceSrcEnd
+     */
     public Integer getDeviceSrcEnd(){
         return this.deviceSrcEnd;
     }
 
     /**
-    * 设置 结束 设备来源(0.子设备，1.网关设备，2.直连设备)
-    * @param deviceSrcEnd
-    */
+     * 设置 结束 设备来源(0.子设备，1.网关设备，2.直连设备)
+     * @param deviceSrcEnd
+     */
     public void setDeviceSrcEnd(Integer deviceSrcEnd){
         this.deviceSrcEnd = deviceSrcEnd;
     }
 
     /**
-    * 获取 增加 设备来源(0.子设备，1.网关设备，2.直连设备)
-    * @return deviceSrcIncrement
-    */
+     * 获取 增加 设备来源(0.子设备，1.网关设备，2.直连设备)
+     * @return deviceSrcIncrement
+     */
     public Integer getDeviceSrcIncrement(){
         return this.deviceSrcIncrement;
     }
 
     /**
-    * 设置 增加 设备来源(0.子设备，1.网关设备，2.直连设备)
-    * @param deviceSrcIncrement
-    */
+     * 设置 增加 设备来源(0.子设备，1.网关设备，2.直连设备)
+     * @param deviceSrcIncrement
+     */
     public void setDeviceSrcIncrement(Integer deviceSrcIncrement){
         this.deviceSrcIncrement = deviceSrcIncrement;
     }
 
     /**
-    * 获取 设备来源(0.子设备，1.网关设备，2.直连设备)
-    * @return deviceSrcList
-    */
+     * 获取 设备来源(0.子设备，1.网关设备，2.直连设备)
+     * @return deviceSrcList
+     */
     public List<Integer> getDeviceSrcList(){
         return this.deviceSrcList;
     }
 
     /**
-    * 设置 设备来源(0.子设备，1.网关设备，2.直连设备)
-    * @param deviceSrcList
-    */
+     * 设置 设备来源(0.子设备，1.网关设备，2.直连设备)
+     * @param deviceSrcList
+     */
     public void setDeviceSrcList(List<Integer> deviceSrcList){
         this.deviceSrcList = deviceSrcList;
     }
 
     /**
-    * 获取 设备来源(0.子设备，1.网关设备，2.直连设备)
-    * @return deviceSrcNotList
-    */
+     * 获取 设备来源(0.子设备，1.网关设备，2.直连设备)
+     * @return deviceSrcNotList
+     */
     public List<Integer> getDeviceSrcNotList(){
         return this.deviceSrcNotList;
     }
 
     /**
-    * 设置 设备来源(0.子设备，1.网关设备，2.直连设备)
-    * @param deviceSrcNotList
-    */
+     * 设置 设备来源(0.子设备，1.网关设备，2.直连设备)
+     * @param deviceSrcNotList
+     */
     public void setDeviceSrcNotList(List<Integer> deviceSrcNotList){
         this.deviceSrcNotList = deviceSrcNotList;
     }
 
 
     /**
-    * 获取 经度
-    * @return lonList
-    */
+     * 获取 经度
+     * @return lonList
+     */
     public List<String> getLonList(){
         return this.lonList;
     }
 
     /**
-    * 设置 经度
-    * @param lonList
-    */
+     * 设置 经度
+     * @param lonList
+     */
     public void setLonList(List<String> lonList){
         this.lonList = lonList;
     }
 
     /**
-    * 获取 经度
-    * @return lonNotList
-    */
+     * 获取 经度
+     * @return lonNotList
+     */
     public List<String> getLonNotList(){
         return this.lonNotList;
     }
 
     /**
-    * 设置 经度
-    * @param lonNotList
-    */
+     * 设置 经度
+     * @param lonNotList
+     */
     public void setLonNotList(List<String> lonNotList){
         this.lonNotList = lonNotList;
     }
 
     /**
-    * 获取 纬度
-    * @return latiList
-    */
+     * 获取 纬度
+     * @return latiList
+     */
     public List<String> getLatiList(){
         return this.latiList;
     }
 
     /**
-    * 设置 纬度
-    * @param latiList
-    */
+     * 设置 纬度
+     * @param latiList
+     */
     public void setLatiList(List<String> latiList){
         this.latiList = latiList;
     }
 
     /**
-    * 获取 纬度
-    * @return latiNotList
-    */
+     * 获取 纬度
+     * @return latiNotList
+     */
     public List<String> getLatiNotList(){
         return this.latiNotList;
     }
 
     /**
-    * 设置 纬度
-    * @param latiNotList
-    */
+     * 设置 纬度
+     * @param latiNotList
+     */
     public void setLatiNotList(List<String> latiNotList){
         this.latiNotList = latiNotList;
     }
 
     /**
-    * 获取 负责人
-    * @return leadingOfficialList
-    */
+     * 获取 负责人
+     * @return leadingOfficialList
+     */
     public List<String> getLeadingOfficialList(){
         return this.leadingOfficialList;
     }
 
     /**
-    * 设置 负责人
-    * @param leadingOfficialList
-    */
+     * 设置 负责人
+     * @param leadingOfficialList
+     */
     public void setLeadingOfficialList(List<String> leadingOfficialList){
         this.leadingOfficialList = leadingOfficialList;
     }
 
     /**
-    * 获取 负责人
-    * @return leadingOfficialNotList
-    */
+     * 获取 负责人
+     * @return leadingOfficialNotList
+     */
     public List<String> getLeadingOfficialNotList(){
         return this.leadingOfficialNotList;
     }
 
     /**
-    * 设置 负责人
-    * @param leadingOfficialNotList
-    */
+     * 设置 负责人
+     * @param leadingOfficialNotList
+     */
     public void setLeadingOfficialNotList(List<String> leadingOfficialNotList){
         this.leadingOfficialNotList = leadingOfficialNotList;
     }
 
     /**
-    * 获取 联系电话
-    * @return leadingOfficialTelephoneList
-    */
+     * 获取 联系电话
+     * @return leadingOfficialTelephoneList
+     */
     public List<String> getLeadingOfficialTelephoneList(){
         return this.leadingOfficialTelephoneList;
     }
 
     /**
-    * 设置 联系电话
-    * @param leadingOfficialTelephoneList
-    */
+     * 设置 联系电话
+     * @param leadingOfficialTelephoneList
+     */
     public void setLeadingOfficialTelephoneList(List<String> leadingOfficialTelephoneList){
         this.leadingOfficialTelephoneList = leadingOfficialTelephoneList;
     }
 
     /**
-    * 获取 联系电话
-    * @return leadingOfficialTelephoneNotList
-    */
+     * 获取 联系电话
+     * @return leadingOfficialTelephoneNotList
+     */
     public List<String> getLeadingOfficialTelephoneNotList(){
         return this.leadingOfficialTelephoneNotList;
     }
 
     /**
-    * 设置 联系电话
-    * @param leadingOfficialTelephoneNotList
-    */
+     * 设置 联系电话
+     * @param leadingOfficialTelephoneNotList
+     */
     public void setLeadingOfficialTelephoneNotList(List<String> leadingOfficialTelephoneNotList){
         this.leadingOfficialTelephoneNotList = leadingOfficialTelephoneNotList;
     }
 
     /**
-    * 获取 开始 设备状态 (0.未激活，1.离线,2.在线)
-    * @return deviceStatusStart
-    */
+     * 获取 开始 设备状态 (0.未激活，1.离线,2.在线)
+     * @return deviceStatusStart
+     */
     public Integer getDeviceStatusStart(){
         return this.deviceStatusStart;
     }
 
     /**
-    * 设置 开始 设备状态 (0.未激活，1.离线,2.在线)
-    * @param deviceStatusStart
-    */
+     * 设置 开始 设备状态 (0.未激活，1.离线,2.在线)
+     * @param deviceStatusStart
+     */
     public void setDeviceStatusStart(Integer deviceStatusStart){
         this.deviceStatusStart = deviceStatusStart;
     }
 
     /**
-    * 获取 结束 设备状态 (0.未激活，1.离线,2.在线)
-    * @return $deviceStatusEnd
-    */
+     * 获取 结束 设备状态 (0.未激活，1.离线,2.在线)
+     * @return $deviceStatusEnd
+     */
     public Integer getDeviceStatusEnd(){
         return this.deviceStatusEnd;
     }
 
     /**
-    * 设置 结束 设备状态 (0.未激活，1.离线,2.在线)
-    * @param deviceStatusEnd
-    */
+     * 设置 结束 设备状态 (0.未激活，1.离线,2.在线)
+     * @param deviceStatusEnd
+     */
     public void setDeviceStatusEnd(Integer deviceStatusEnd){
         this.deviceStatusEnd = deviceStatusEnd;
     }
 
     /**
-    * 获取 增加 设备状态 (0.未激活，1.离线,2.在线)
-    * @return deviceStatusIncrement
-    */
+     * 获取 增加 设备状态 (0.未激活，1.离线,2.在线)
+     * @return deviceStatusIncrement
+     */
     public Integer getDeviceStatusIncrement(){
         return this.deviceStatusIncrement;
     }
 
     /**
-    * 设置 增加 设备状态 (0.未激活，1.离线,2.在线)
-    * @param deviceStatusIncrement
-    */
+     * 设置 增加 设备状态 (0.未激活，1.离线,2.在线)
+     * @param deviceStatusIncrement
+     */
     public void setDeviceStatusIncrement(Integer deviceStatusIncrement){
         this.deviceStatusIncrement = deviceStatusIncrement;
     }
 
     /**
-    * 获取 设备状态 (0.未激活，1.离线,2.在线)
-    * @return deviceStatusList
-    */
+     * 获取 设备状态 (0.未激活，1.离线,2.在线)
+     * @return deviceStatusList
+     */
     public List<Integer> getDeviceStatusList(){
         return this.deviceStatusList;
     }
 
     /**
-    * 设置 设备状态 (0.未激活，1.离线,2.在线)
-    * @param deviceStatusList
-    */
+     * 设置 设备状态 (0.未激活，1.离线,2.在线)
+     * @param deviceStatusList
+     */
     public void setDeviceStatusList(List<Integer> deviceStatusList){
         this.deviceStatusList = deviceStatusList;
     }
 
     /**
-    * 获取 设备状态 (0.未激活，1.离线,2.在线)
-    * @return deviceStatusNotList
-    */
+     * 获取 设备状态 (0.未激活，1.离线,2.在线)
+     * @return deviceStatusNotList
+     */
     public List<Integer> getDeviceStatusNotList(){
         return this.deviceStatusNotList;
     }
 
     /**
-    * 设置 设备状态 (0.未激活，1.离线,2.在线)
-    * @param deviceStatusNotList
-    */
+     * 设置 设备状态 (0.未激活，1.离线,2.在线)
+     * @param deviceStatusNotList
+     */
     public void setDeviceStatusNotList(List<Integer> deviceStatusNotList){
         this.deviceStatusNotList = deviceStatusNotList;
     }
 
 
     /**
-    * 获取 备注
-    * @return deviceRemarkList
-    */
+     * 获取 备注
+     * @return deviceRemarkList
+     */
     public List<String> getDeviceRemarkList(){
         return this.deviceRemarkList;
     }
 
     /**
-    * 设置 备注
-    * @param deviceRemarkList
-    */
+     * 设置 备注
+     * @param deviceRemarkList
+     */
     public void setDeviceRemarkList(List<String> deviceRemarkList){
         this.deviceRemarkList = deviceRemarkList;
     }
 
     /**
-    * 获取 备注
-    * @return deviceRemarkNotList
-    */
+     * 获取 备注
+     * @return deviceRemarkNotList
+     */
     public List<String> getDeviceRemarkNotList(){
         return this.deviceRemarkNotList;
     }
 
     /**
-    * 设置 备注
-    * @param deviceRemarkNotList
-    */
+     * 设置 备注
+     * @param deviceRemarkNotList
+     */
     public void setDeviceRemarkNotList(List<String> deviceRemarkNotList){
         this.deviceRemarkNotList = deviceRemarkNotList;
     }
 
     /**
-    * 获取 开始 设备来源(0.旧设备，1.新设备)
-    * @return sourceStart
-    */
+     * 获取 开始 设备来源(0.旧设备，1.新设备)
+     * @return sourceStart
+     */
     public Integer getSourceStart(){
         return this.sourceStart;
     }
 
     /**
-    * 设置 开始 设备来源(0.旧设备，1.新设备)
-    * @param sourceStart
-    */
+     * 设置 开始 设备来源(0.旧设备，1.新设备)
+     * @param sourceStart
+     */
     public void setSourceStart(Integer sourceStart){
         this.sourceStart = sourceStart;
     }
 
     /**
-    * 获取 结束 设备来源(0.旧设备，1.新设备)
-    * @return $sourceEnd
-    */
+     * 获取 结束 设备来源(0.旧设备，1.新设备)
+     * @return $sourceEnd
+     */
     public Integer getSourceEnd(){
         return this.sourceEnd;
     }
 
     /**
-    * 设置 结束 设备来源(0.旧设备，1.新设备)
-    * @param sourceEnd
-    */
+     * 设置 结束 设备来源(0.旧设备，1.新设备)
+     * @param sourceEnd
+     */
     public void setSourceEnd(Integer sourceEnd){
         this.sourceEnd = sourceEnd;
     }
 
     /**
-    * 获取 增加 设备来源(0.旧设备，1.新设备)
-    * @return sourceIncrement
-    */
+     * 获取 增加 设备来源(0.旧设备，1.新设备)
+     * @return sourceIncrement
+     */
     public Integer getSourceIncrement(){
         return this.sourceIncrement;
     }
 
     /**
-    * 设置 增加 设备来源(0.旧设备，1.新设备)
-    * @param sourceIncrement
-    */
+     * 设置 增加 设备来源(0.旧设备，1.新设备)
+     * @param sourceIncrement
+     */
     public void setSourceIncrement(Integer sourceIncrement){
         this.sourceIncrement = sourceIncrement;
     }
 
     /**
-    * 获取 设备来源(0.旧设备，1.新设备)
-    * @return sourceList
-    */
+     * 获取 设备来源(0.旧设备，1.新设备)
+     * @return sourceList
+     */
     public List<Integer> getSourceList(){
         return this.sourceList;
     }
 
     /**
-    * 设置 设备来源(0.旧设备，1.新设备)
-    * @param sourceList
-    */
+     * 设置 设备来源(0.旧设备，1.新设备)
+     * @param sourceList
+     */
     public void setSourceList(List<Integer> sourceList){
         this.sourceList = sourceList;
     }
 
     /**
-    * 获取 设备来源(0.旧设备，1.新设备)
-    * @return sourceNotList
-    */
+     * 获取 设备来源(0.旧设备，1.新设备)
+     * @return sourceNotList
+     */
     public List<Integer> getSourceNotList(){
         return this.sourceNotList;
     }
 
     /**
-    * 设置 设备来源(0.旧设备，1.新设备)
-    * @param sourceNotList
-    */
+     * 设置 设备来源(0.旧设备，1.新设备)
+     * @param sourceNotList
+     */
     public void setSourceNotList(List<Integer> sourceNotList){
         this.sourceNotList = sourceNotList;
     }
 
 
     /**
-    * 获取 开始 创建用户
-    * @return createUserIdStart
-    */
+     * 获取 开始 创建用户
+     * @return createUserIdStart
+     */
     public Long getCreateUserIdStart(){
         return this.createUserIdStart;
     }
 
     /**
-    * 设置 开始 创建用户
-    * @param createUserIdStart
-    */
+     * 设置 开始 创建用户
+     * @param createUserIdStart
+     */
     public void setCreateUserIdStart(Long createUserIdStart){
         this.createUserIdStart = createUserIdStart;
     }
 
     /**
-    * 获取 结束 创建用户
-    * @return $createUserIdEnd
-    */
+     * 获取 结束 创建用户
+     * @return $createUserIdEnd
+     */
     public Long getCreateUserIdEnd(){
         return this.createUserIdEnd;
     }
 
     /**
-    * 设置 结束 创建用户
-    * @param createUserIdEnd
-    */
+     * 设置 结束 创建用户
+     * @param createUserIdEnd
+     */
     public void setCreateUserIdEnd(Long createUserIdEnd){
         this.createUserIdEnd = createUserIdEnd;
     }
 
     /**
-    * 获取 增加 创建用户
-    * @return createUserIdIncrement
-    */
+     * 获取 增加 创建用户
+     * @return createUserIdIncrement
+     */
     public Long getCreateUserIdIncrement(){
         return this.createUserIdIncrement;
     }
 
     /**
-    * 设置 增加 创建用户
-    * @param createUserIdIncrement
-    */
+     * 设置 增加 创建用户
+     * @param createUserIdIncrement
+     */
     public void setCreateUserIdIncrement(Long createUserIdIncrement){
         this.createUserIdIncrement = createUserIdIncrement;
     }
 
     /**
-    * 获取 创建用户
-    * @return createUserIdList
-    */
+     * 获取 创建用户
+     * @return createUserIdList
+     */
     public List<Long> getCreateUserIdList(){
         return this.createUserIdList;
     }
 
     /**
-    * 设置 创建用户
-    * @param createUserIdList
-    */
+     * 设置 创建用户
+     * @param createUserIdList
+     */
     public void setCreateUserIdList(List<Long> createUserIdList){
         this.createUserIdList = createUserIdList;
     }
 
     /**
-    * 获取 创建用户
-    * @return createUserIdNotList
-    */
+     * 获取 创建用户
+     * @return createUserIdNotList
+     */
     public List<Long> getCreateUserIdNotList(){
         return this.createUserIdNotList;
     }
 
     /**
-    * 设置 创建用户
-    * @param createUserIdNotList
-    */
+     * 设置 创建用户
+     * @param createUserIdNotList
+     */
     public void setCreateUserIdNotList(List<Long> createUserIdNotList){
         this.createUserIdNotList = createUserIdNotList;
     }
 
 
     /**
-    * 获取 开始 创建时间
-    * @return createTimeStart
-    */
+     * 获取 开始 创建时间
+     * @return createTimeStart
+     */
     public String getCreateTimeStart(){
         return this.createTimeStart;
     }
 
     /**
-    * 设置 开始 创建时间
-    * @param createTimeStart
-    */
+     * 设置 开始 创建时间
+     * @param createTimeStart
+     */
     public void setCreateTimeStart(String createTimeStart){
         this.createTimeStart = createTimeStart;
     }
 
     /**
-    * 获取 结束 创建时间
-    * @return createTimeEnd
-    */
+     * 获取 结束 创建时间
+     * @return createTimeEnd
+     */
     public String getCreateTimeEnd(){
         return this.createTimeEnd;
     }
 
     /**
-    * 设置 结束 创建时间
-    * @param createTimeEnd
-    */
+     * 设置 结束 创建时间
+     * @param createTimeEnd
+     */
     public void setCreateTimeEnd(String createTimeEnd){
         this.createTimeEnd = createTimeEnd;
     }
 
     /**
-    * 获取 开始 更新用户
-    * @return updateUserIdStart
-    */
+     * 获取 开始 更新用户
+     * @return updateUserIdStart
+     */
     public Long getUpdateUserIdStart(){
         return this.updateUserIdStart;
     }
 
     /**
-    * 设置 开始 更新用户
-    * @param updateUserIdStart
-    */
+     * 设置 开始 更新用户
+     * @param updateUserIdStart
+     */
     public void setUpdateUserIdStart(Long updateUserIdStart){
         this.updateUserIdStart = updateUserIdStart;
     }
 
     /**
-    * 获取 结束 更新用户
-    * @return $updateUserIdEnd
-    */
+     * 获取 结束 更新用户
+     * @return $updateUserIdEnd
+     */
     public Long getUpdateUserIdEnd(){
         return this.updateUserIdEnd;
     }
 
     /**
-    * 设置 结束 更新用户
-    * @param updateUserIdEnd
-    */
+     * 设置 结束 更新用户
+     * @param updateUserIdEnd
+     */
     public void setUpdateUserIdEnd(Long updateUserIdEnd){
         this.updateUserIdEnd = updateUserIdEnd;
     }
 
     /**
-    * 获取 增加 更新用户
-    * @return updateUserIdIncrement
-    */
+     * 获取 增加 更新用户
+     * @return updateUserIdIncrement
+     */
     public Long getUpdateUserIdIncrement(){
         return this.updateUserIdIncrement;
     }
 
     /**
-    * 设置 增加 更新用户
-    * @param updateUserIdIncrement
-    */
+     * 设置 增加 更新用户
+     * @param updateUserIdIncrement
+     */
     public void setUpdateUserIdIncrement(Long updateUserIdIncrement){
         this.updateUserIdIncrement = updateUserIdIncrement;
     }
 
     /**
-    * 获取 更新用户
-    * @return updateUserIdList
-    */
+     * 获取 更新用户
+     * @return updateUserIdList
+     */
     public List<Long> getUpdateUserIdList(){
         return this.updateUserIdList;
     }
 
     /**
-    * 设置 更新用户
-    * @param updateUserIdList
-    */
+     * 设置 更新用户
+     * @param updateUserIdList
+     */
     public void setUpdateUserIdList(List<Long> updateUserIdList){
         this.updateUserIdList = updateUserIdList;
     }
 
     /**
-    * 获取 更新用户
-    * @return updateUserIdNotList
-    */
+     * 获取 更新用户
+     * @return updateUserIdNotList
+     */
     public List<Long> getUpdateUserIdNotList(){
         return this.updateUserIdNotList;
     }
 
     /**
-    * 设置 更新用户
-    * @param updateUserIdNotList
-    */
+     * 设置 更新用户
+     * @param updateUserIdNotList
+     */
     public void setUpdateUserIdNotList(List<Long> updateUserIdNotList){
         this.updateUserIdNotList = updateUserIdNotList;
     }
 
 
     /**
-    * 获取 开始 更新时间
-    * @return updateTimeStart
-    */
+     * 获取 开始 更新时间
+     * @return updateTimeStart
+     */
     public String getUpdateTimeStart(){
         return this.updateTimeStart;
     }
 
     /**
-    * 设置 开始 更新时间
-    * @param updateTimeStart
-    */
+     * 设置 开始 更新时间
+     * @param updateTimeStart
+     */
     public void setUpdateTimeStart(String updateTimeStart){
         this.updateTimeStart = updateTimeStart;
     }
 
     /**
-    * 获取 结束 更新时间
-    * @return updateTimeEnd
-    */
+     * 获取 结束 更新时间
+     * @return updateTimeEnd
+     */
     public String getUpdateTimeEnd(){
         return this.updateTimeEnd;
     }
 
     /**
-    * 设置 结束 更新时间
-    * @param updateTimeEnd
-    */
+     * 设置 结束 更新时间
+     * @param updateTimeEnd
+     */
     public void setUpdateTimeEnd(String updateTimeEnd){
         this.updateTimeEnd = updateTimeEnd;
     }
 
     /**
-    * 设置  主键ID，主键，自增长
-    * @param id
-    */
+     * 获取 开始 设备生产厂商ID
+     * @return deviceFirmIdStart
+     */
+    public Long getDeviceFirmIdStart(){
+        return this.deviceFirmIdStart;
+    }
+
+    /**
+     * 设置 开始 设备生产厂商ID
+     * @param deviceFirmIdStart
+     */
+    public void setDeviceFirmIdStart(Long deviceFirmIdStart){
+        this.deviceFirmIdStart = deviceFirmIdStart;
+    }
+
+    /**
+     * 获取 结束 设备生产厂商ID
+     * @return $deviceFirmIdEnd
+     */
+    public Long getDeviceFirmIdEnd(){
+        return this.deviceFirmIdEnd;
+    }
+
+    /**
+     * 设置 结束 设备生产厂商ID
+     * @param deviceFirmIdEnd
+     */
+    public void setDeviceFirmIdEnd(Long deviceFirmIdEnd){
+        this.deviceFirmIdEnd = deviceFirmIdEnd;
+    }
+
+    /**
+     * 获取 增加 设备生产厂商ID
+     * @return deviceFirmIdIncrement
+     */
+    public Long getDeviceFirmIdIncrement(){
+        return this.deviceFirmIdIncrement;
+    }
+
+    /**
+     * 设置 增加 设备生产厂商ID
+     * @param deviceFirmIdIncrement
+     */
+    public void setDeviceFirmIdIncrement(Long deviceFirmIdIncrement){
+        this.deviceFirmIdIncrement = deviceFirmIdIncrement;
+    }
+
+    /**
+     * 获取 设备生产厂商ID
+     * @return deviceFirmIdList
+     */
+    public List<Long> getDeviceFirmIdList(){
+        return this.deviceFirmIdList;
+    }
+
+    /**
+     * 设置 设备生产厂商ID
+     * @param deviceFirmIdList
+     */
+    public void setDeviceFirmIdList(List<Long> deviceFirmIdList){
+        this.deviceFirmIdList = deviceFirmIdList;
+    }
+
+    /**
+     * 获取 设备生产厂商ID
+     * @return deviceFirmIdNotList
+     */
+    public List<Long> getDeviceFirmIdNotList(){
+        return this.deviceFirmIdNotList;
+    }
+
+    /**
+     * 设置 设备生产厂商ID
+     * @param deviceFirmIdNotList
+     */
+    public void setDeviceFirmIdNotList(List<Long> deviceFirmIdNotList){
+        this.deviceFirmIdNotList = deviceFirmIdNotList;
+    }
+
+
+    /**
+     * 获取 设备生产厂商名称
+     * @return deviceFirmnameList
+     */
+    public List<String> getDeviceFirmnameList(){
+        return this.deviceFirmnameList;
+    }
+
+    /**
+     * 设置 设备生产厂商名称
+     * @param deviceFirmnameList
+     */
+    public void setDeviceFirmnameList(List<String> deviceFirmnameList){
+        this.deviceFirmnameList = deviceFirmnameList;
+    }
+
+    /**
+     * 获取 设备生产厂商名称
+     * @return deviceFirmnameNotList
+     */
+    public List<String> getDeviceFirmnameNotList(){
+        return this.deviceFirmnameNotList;
+    }
+
+    /**
+     * 设置 设备生产厂商名称
+     * @param deviceFirmnameNotList
+     */
+    public void setDeviceFirmnameNotList(List<String> deviceFirmnameNotList){
+        this.deviceFirmnameNotList = deviceFirmnameNotList;
+    }
+
+    /**
+     * 获取 设备访问ip
+     * @return ipList
+     */
+    public List<String> getIpList(){
+        return this.ipList;
+    }
+
+    /**
+     * 设置 设备访问ip
+     * @param ipList
+     */
+    public void setIpList(List<String> ipList){
+        this.ipList = ipList;
+    }
+
+    /**
+     * 获取 设备访问ip
+     * @return ipNotList
+     */
+    public List<String> getIpNotList(){
+        return this.ipNotList;
+    }
+
+    /**
+     * 设置 设备访问ip
+     * @param ipNotList
+     */
+    public void setIpNotList(List<String> ipNotList){
+        this.ipNotList = ipNotList;
+    }
+
+    /**
+     * 获取 端口
+     * @return portList
+     */
+    public List<String> getPortList(){
+        return this.portList;
+    }
+
+    /**
+     * 设置 端口
+     * @param portList
+     */
+    public void setPortList(List<String> portList){
+        this.portList = portList;
+    }
+
+    /**
+     * 获取 端口
+     * @return portNotList
+     */
+    public List<String> getPortNotList(){
+        return this.portNotList;
+    }
+
+    /**
+     * 设置 端口
+     * @param portNotList
+     */
+    public void setPortNotList(List<String> portNotList){
+        this.portNotList = portNotList;
+    }
+
+    /**
+     * 获取 开始 启用状态 (0.停止，1.启用)
+     * @return enabledStart
+     */
+    public Integer getEnabledStart(){
+        return this.enabledStart;
+    }
+
+    /**
+     * 设置 开始 启用状态 (0.停止，1.启用)
+     * @param enabledStart
+     */
+    public void setEnabledStart(Integer enabledStart){
+        this.enabledStart = enabledStart;
+    }
+
+    /**
+     * 获取 结束 启用状态 (0.停止，1.启用)
+     * @return $enabledEnd
+     */
+    public Integer getEnabledEnd(){
+        return this.enabledEnd;
+    }
+
+    /**
+     * 设置 结束 启用状态 (0.停止，1.启用)
+     * @param enabledEnd
+     */
+    public void setEnabledEnd(Integer enabledEnd){
+        this.enabledEnd = enabledEnd;
+    }
+
+    /**
+     * 获取 增加 启用状态 (0.停止，1.启用)
+     * @return enabledIncrement
+     */
+    public Integer getEnabledIncrement(){
+        return this.enabledIncrement;
+    }
+
+    /**
+     * 设置 增加 启用状态 (0.停止，1.启用)
+     * @param enabledIncrement
+     */
+    public void setEnabledIncrement(Integer enabledIncrement){
+        this.enabledIncrement = enabledIncrement;
+    }
+
+    /**
+     * 获取 启用状态 (0.停止，1.启用)
+     * @return enabledList
+     */
+    public List<Integer> getEnabledList(){
+        return this.enabledList;
+    }
+
+    /**
+     * 设置 启用状态 (0.停止，1.启用)
+     * @param enabledList
+     */
+    public void setEnabledList(List<Integer> enabledList){
+        this.enabledList = enabledList;
+    }
+
+    /**
+     * 获取 启用状态 (0.停止，1.启用)
+     * @return enabledNotList
+     */
+    public List<Integer> getEnabledNotList(){
+        return this.enabledNotList;
+    }
+
+    /**
+     * 设置 启用状态 (0.停止，1.启用)
+     * @param enabledNotList
+     */
+    public void setEnabledNotList(List<Integer> enabledNotList){
+        this.enabledNotList = enabledNotList;
+    }
+
+
+    /**
+     * 获取 开始 最近上线时间
+     * @return onlineTimeStart
+     */
+    public String getOnlineTimeStart(){
+        return this.onlineTimeStart;
+    }
+
+    /**
+     * 设置 开始 最近上线时间
+     * @param onlineTimeStart
+     */
+    public void setOnlineTimeStart(String onlineTimeStart){
+        this.onlineTimeStart = onlineTimeStart;
+    }
+
+    /**
+     * 获取 结束 最近上线时间
+     * @return onlineTimeEnd
+     */
+    public String getOnlineTimeEnd(){
+        return this.onlineTimeEnd;
+    }
+
+    /**
+     * 设置 结束 最近上线时间
+     * @param onlineTimeEnd
+     */
+    public void setOnlineTimeEnd(String onlineTimeEnd){
+        this.onlineTimeEnd = onlineTimeEnd;
+    }
+
+    /**
+     * 获取 开始 最近离线时间
+     * @return offlineTimeStart
+     */
+    public String getOfflineTimeStart(){
+        return this.offlineTimeStart;
+    }
+
+    /**
+     * 设置 开始 最近离线时间
+     * @param offlineTimeStart
+     */
+    public void setOfflineTimeStart(String offlineTimeStart){
+        this.offlineTimeStart = offlineTimeStart;
+    }
+
+    /**
+     * 获取 结束 最近离线时间
+     * @return offlineTimeEnd
+     */
+    public String getOfflineTimeEnd(){
+        return this.offlineTimeEnd;
+    }
+
+    /**
+     * 设置 结束 最近离线时间
+     * @param offlineTimeEnd
+     */
+    public void setOfflineTimeEnd(String offlineTimeEnd){
+        this.offlineTimeEnd = offlineTimeEnd;
+    }
+
+    /**
+     * 设置  主键ID，主键，自增长
+     * @param id
+     */
     public DeviceQuery id(Long id){
-	    setId(id);
-		return this;
-    }
-	
-	 /**
-    * 设置 开始 主键ID，主键，自增长
-    * @param idStart
-    */
+        setId(id);
+        return this;
+    }
+
+    /**
+     * 设置 开始 主键ID，主键，自增长
+     * @param idStart
+     */
     public DeviceQuery idStart(Long idStart){
-		this.idStart = idStart;
-		return this;
+        this.idStart = idStart;
+        return this;
     }
 
     /**
-    * 设置 结束 主键ID，主键，自增长
-    * @param idEnd
-    */
+     * 设置 结束 主键ID，主键，自增长
+     * @param idEnd
+     */
     public DeviceQuery idEnd(Long idEnd){
-		this.idEnd = idEnd;
-		return this;
+        this.idEnd = idEnd;
+        return this;
     }
 
     /**
-    * 设置 增加 主键ID，主键，自增长
-    * @param idIncrement
-    */
+     * 设置 增加 主键ID，主键，自增长
+     * @param idIncrement
+     */
     public DeviceQuery idIncrement(Long idIncrement){
-		this.idIncrement = idIncrement;
-		return this;
+        this.idIncrement = idIncrement;
+        return this;
     }
 
     /**
-    * 设置 主键ID，主键，自增长
-    * @param idList
-    */
+     * 设置 主键ID，主键，自增长
+     * @param idList
+     */
     public DeviceQuery idList(List<Long> idList){
         this.idList = idList;
-		return this;
-        }
-
-        /**
-        * 设置 主键ID，主键，自增长
-        * @param idNotList
-        */
-        public DeviceQuery idNotList(List<Long> idNotList){
+        return this;
+    }
+
+    /**
+     * 设置 主键ID，主键，自增长
+     * @param idNotList
+     */
+    public DeviceQuery idNotList(List<Long> idNotList){
         this.idNotList = idNotList;
         return this;
-        }
+    }
 
     /**
-    * 设置  设备id
-    * @param deviceId
-    */
+     * 设置  设备id
+     * @param deviceId
+     */
     public DeviceQuery deviceId(Long deviceId){
-	    setDeviceId(deviceId);
-		return this;
-    }
-	
-	 /**
-    * 设置 开始 设备id
-    * @param deviceIdStart
-    */
+        setDeviceId(deviceId);
+        return this;
+    }
+
+    /**
+     * 设置 开始 设备id
+     * @param deviceIdStart
+     */
     public DeviceQuery deviceIdStart(Long deviceIdStart){
-		this.deviceIdStart = deviceIdStart;
-		return this;
+        this.deviceIdStart = deviceIdStart;
+        return this;
     }
 
     /**
-    * 设置 结束 设备id
-    * @param deviceIdEnd
-    */
+     * 设置 结束 设备id
+     * @param deviceIdEnd
+     */
     public DeviceQuery deviceIdEnd(Long deviceIdEnd){
-		this.deviceIdEnd = deviceIdEnd;
-		return this;
+        this.deviceIdEnd = deviceIdEnd;
+        return this;
     }
 
     /**
-    * 设置 增加 设备id
-    * @param deviceIdIncrement
-    */
+     * 设置 增加 设备id
+     * @param deviceIdIncrement
+     */
     public DeviceQuery deviceIdIncrement(Long deviceIdIncrement){
-		this.deviceIdIncrement = deviceIdIncrement;
-		return this;
+        this.deviceIdIncrement = deviceIdIncrement;
+        return this;
     }
 
     /**
-    * 设置 设备id
-    * @param deviceIdList
-    */
+     * 设置 设备id
+     * @param deviceIdList
+     */
     public DeviceQuery deviceIdList(List<Long> deviceIdList){
         this.deviceIdList = deviceIdList;
-		return this;
-        }
-
-        /**
-        * 设置 设备id
-        * @param deviceIdNotList
-        */
-        public DeviceQuery deviceIdNotList(List<Long> deviceIdNotList){
+        return this;
+    }
+
+    /**
+     * 设置 设备id
+     * @param deviceIdNotList
+     */
+    public DeviceQuery deviceIdNotList(List<Long> deviceIdNotList){
         this.deviceIdNotList = deviceIdNotList;
         return this;
-        }
+    }
 
 
-	/**
-    * 设置 设备名称
-    * @param deviceName
-    */
+    /**
+     * 设置 设备名称
+     * @param deviceName
+     */
     public DeviceQuery deviceName(String deviceName){
         setDeviceName(deviceName);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 设备名称
-    * @param deviceNameList
-    */
+     * 设置 设备名称
+     * @param deviceNameList
+     */
     public DeviceQuery deviceNameList(List<String> deviceNameList){
         this.deviceNameList = deviceNameList;
-		return this;
+        return this;
     }
 
 
-	/**
-    * 设置 设备编码
-    * @param deviceCode
-    */
+    /**
+     * 设置 设备编码
+     * @param deviceCode
+     */
     public DeviceQuery deviceCode(String deviceCode){
         setDeviceCode(deviceCode);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 设备编码
-    * @param deviceCodeList
-    */
+     * 设置 设备编码
+     * @param deviceCodeList
+     */
     public DeviceQuery deviceCodeList(List<String> deviceCodeList){
         this.deviceCodeList = deviceCodeList;
-		return this;
+        return this;
     }
 
 
-	/**
-    * 设置 设备的MAC地址
-    * @param deviceMac
-    */
+    /**
+     * 设置 设备的MAC地址
+     * @param deviceMac
+     */
     public DeviceQuery deviceMac(String deviceMac){
         setDeviceMac(deviceMac);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 设备的MAC地址
-    * @param deviceMacList
-    */
+     * 设置 设备的MAC地址
+     * @param deviceMacList
+     */
     public DeviceQuery deviceMacList(List<String> deviceMacList){
         this.deviceMacList = deviceMacList;
-		return this;
+        return this;
     }
 
     /**
-    * 设置  站点Id
-    * @param siteId
-    */
+     * 设置  站点Id
+     * @param siteId
+     */
     public DeviceQuery siteId(Long siteId){
-	    setSiteId(siteId);
-		return this;
-    }
-	
-	 /**
-    * 设置 开始 站点Id
-    * @param siteIdStart
-    */
+        setSiteId(siteId);
+        return this;
+    }
+
+    /**
+     * 设置 开始 站点Id
+     * @param siteIdStart
+     */
     public DeviceQuery siteIdStart(Long siteIdStart){
-		this.siteIdStart = siteIdStart;
-		return this;
+        this.siteIdStart = siteIdStart;
+        return this;
     }
 
     /**
-    * 设置 结束 站点Id
-    * @param siteIdEnd
-    */
+     * 设置 结束 站点Id
+     * @param siteIdEnd
+     */
     public DeviceQuery siteIdEnd(Long siteIdEnd){
-		this.siteIdEnd = siteIdEnd;
-		return this;
+        this.siteIdEnd = siteIdEnd;
+        return this;
     }
 
     /**
-    * 设置 增加 站点Id
-    * @param siteIdIncrement
-    */
+     * 设置 增加 站点Id
+     * @param siteIdIncrement
+     */
     public DeviceQuery siteIdIncrement(Long siteIdIncrement){
-		this.siteIdIncrement = siteIdIncrement;
-		return this;
+        this.siteIdIncrement = siteIdIncrement;
+        return this;
     }
 
     /**
-    * 设置 站点Id
-    * @param siteIdList
-    */
+     * 设置 站点Id
+     * @param siteIdList
+     */
     public DeviceQuery siteIdList(List<Long> siteIdList){
         this.siteIdList = siteIdList;
-		return this;
-        }
-
-        /**
-        * 设置 站点Id
-        * @param siteIdNotList
-        */
-        public DeviceQuery siteIdNotList(List<Long> siteIdNotList){
+        return this;
+    }
+
+    /**
+     * 设置 站点Id
+     * @param siteIdNotList
+     */
+    public DeviceQuery siteIdNotList(List<Long> siteIdNotList){
         this.siteIdNotList = siteIdNotList;
         return this;
-        }
+    }
 
 
-	/**
-    * 设置 站点编号，来源基础服务平台
-    * @param siteCode
-    */
+    /**
+     * 设置 站点编号，来源基础服务平台
+     * @param siteCode
+     */
     public DeviceQuery siteCode(String siteCode){
         setSiteCode(siteCode);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 站点编号，来源基础服务平台
-    * @param siteCodeList
-    */
+     * 设置 站点编号，来源基础服务平台
+     * @param siteCodeList
+     */
     public DeviceQuery siteCodeList(List<String> siteCodeList){
         this.siteCodeList = siteCodeList;
-		return this;
+        return this;
     }
 
 
-	/**
-    * 设置 站点名称
-    * @param siteName
-    */
+    /**
+     * 设置 站点名称
+     * @param siteName
+     */
     public DeviceQuery siteName(String siteName){
         setSiteName(siteName);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 站点名称
-    * @param siteNameList
-    */
+     * 设置 站点名称
+     * @param siteNameList
+     */
     public DeviceQuery siteNameList(List<String> siteNameList){
         this.siteNameList = siteNameList;
-		return this;
+        return this;
     }
 
 
-	/**
-    * 设置 产品编码
-    * @param productCode
-    */
+    /**
+     * 设置 产品编码
+     * @param productCode
+     */
     public DeviceQuery productCode(String productCode){
         setProductCode(productCode);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 产品编码
-    * @param productCodeList
-    */
+     * 设置 产品编码
+     * @param productCodeList
+     */
     public DeviceQuery productCodeList(List<String> productCodeList){
         this.productCodeList = productCodeList;
-		return this;
+        return this;
     }
 
 
-	/**
-    * 设置 产品名称
-    * @param productName
-    */
+    /**
+     * 设置 产品名称
+     * @param productName
+     */
     public DeviceQuery productName(String productName){
         setProductName(productName);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 产品名称
-    * @param productNameList
-    */
+     * 设置 产品名称
+     * @param productNameList
+     */
     public DeviceQuery productNameList(List<String> productNameList){
         this.productNameList = productNameList;
-		return this;
+        return this;
     }
 
     /**
-    * 设置  设备来源(0.子设备，1.网关设备，2.直连设备)
-    * @param deviceSrc
-    */
+     * 设置  设备来源(0.子设备，1.网关设备，2.直连设备)
+     * @param deviceSrc
+     */
     public DeviceQuery deviceSrc(Integer deviceSrc){
-	    setDeviceSrc(deviceSrc);
-		return this;
-    }
-	
-	 /**
-    * 设置 开始 设备来源(0.子设备，1.网关设备，2.直连设备)
-    * @param deviceSrcStart
-    */
+        setDeviceSrc(deviceSrc);
+        return this;
+    }
+
+    /**
+     * 设置 开始 设备来源(0.子设备，1.网关设备，2.直连设备)
+     * @param deviceSrcStart
+     */
     public DeviceQuery deviceSrcStart(Integer deviceSrcStart){
-		this.deviceSrcStart = deviceSrcStart;
-		return this;
+        this.deviceSrcStart = deviceSrcStart;
+        return this;
     }
 
     /**
-    * 设置 结束 设备来源(0.子设备，1.网关设备，2.直连设备)
-    * @param deviceSrcEnd
-    */
+     * 设置 结束 设备来源(0.子设备，1.网关设备，2.直连设备)
+     * @param deviceSrcEnd
+     */
     public DeviceQuery deviceSrcEnd(Integer deviceSrcEnd){
-		this.deviceSrcEnd = deviceSrcEnd;
-		return this;
+        this.deviceSrcEnd = deviceSrcEnd;
+        return this;
     }
 
     /**
-    * 设置 增加 设备来源(0.子设备，1.网关设备，2.直连设备)
-    * @param deviceSrcIncrement
-    */
+     * 设置 增加 设备来源(0.子设备，1.网关设备，2.直连设备)
+     * @param deviceSrcIncrement
+     */
     public DeviceQuery deviceSrcIncrement(Integer deviceSrcIncrement){
-		this.deviceSrcIncrement = deviceSrcIncrement;
-		return this;
+        this.deviceSrcIncrement = deviceSrcIncrement;
+        return this;
     }
 
     /**
-    * 设置 设备来源(0.子设备，1.网关设备，2.直连设备)
-    * @param deviceSrcList
-    */
+     * 设置 设备来源(0.子设备，1.网关设备，2.直连设备)
+     * @param deviceSrcList
+     */
     public DeviceQuery deviceSrcList(List<Integer> deviceSrcList){
         this.deviceSrcList = deviceSrcList;
-		return this;
-        }
-
-        /**
-        * 设置 设备来源(0.子设备，1.网关设备，2.直连设备)
-        * @param deviceSrcNotList
-        */
-        public DeviceQuery deviceSrcNotList(List<Integer> deviceSrcNotList){
+        return this;
+    }
+
+    /**
+     * 设置 设备来源(0.子设备，1.网关设备，2.直连设备)
+     * @param deviceSrcNotList
+     */
+    public DeviceQuery deviceSrcNotList(List<Integer> deviceSrcNotList){
         this.deviceSrcNotList = deviceSrcNotList;
         return this;
-        }
+    }
 
 
-	/**
-    * 设置 经度
-    * @param lon
-    */
+    /**
+     * 设置 经度
+     * @param lon
+     */
     public DeviceQuery lon(String lon){
         setLon(lon);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 经度
-    * @param lonList
-    */
+     * 设置 经度
+     * @param lonList
+     */
     public DeviceQuery lonList(List<String> lonList){
         this.lonList = lonList;
-		return this;
+        return this;
     }
 
 
-	/**
-    * 设置 纬度
-    * @param lati
-    */
+    /**
+     * 设置 纬度
+     * @param lati
+     */
     public DeviceQuery lati(String lati){
         setLati(lati);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 纬度
-    * @param latiList
-    */
+     * 设置 纬度
+     * @param latiList
+     */
     public DeviceQuery latiList(List<String> latiList){
         this.latiList = latiList;
-		return this;
+        return this;
     }
 
 
-	/**
-    * 设置 负责人
-    * @param leadingOfficial
-    */
+    /**
+     * 设置 负责人
+     * @param leadingOfficial
+     */
     public DeviceQuery leadingOfficial(String leadingOfficial){
         setLeadingOfficial(leadingOfficial);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 负责人
-    * @param leadingOfficialList
-    */
+     * 设置 负责人
+     * @param leadingOfficialList
+     */
     public DeviceQuery leadingOfficialList(List<String> leadingOfficialList){
         this.leadingOfficialList = leadingOfficialList;
-		return this;
+        return this;
     }
 
 
-	/**
-    * 设置 联系电话
-    * @param leadingOfficialTelephone
-    */
+    /**
+     * 设置 联系电话
+     * @param leadingOfficialTelephone
+     */
     public DeviceQuery leadingOfficialTelephone(String leadingOfficialTelephone){
         setLeadingOfficialTelephone(leadingOfficialTelephone);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 联系电话
-    * @param leadingOfficialTelephoneList
-    */
+     * 设置 联系电话
+     * @param leadingOfficialTelephoneList
+     */
     public DeviceQuery leadingOfficialTelephoneList(List<String> leadingOfficialTelephoneList){
         this.leadingOfficialTelephoneList = leadingOfficialTelephoneList;
-		return this;
+        return this;
     }
 
     /**
-    * 设置  设备状态 (0.未激活，1.离线,2.在线)
-    * @param deviceStatus
-    */
+     * 设置  设备状态 (0.未激活，1.离线,2.在线)
+     * @param deviceStatus
+     */
     public DeviceQuery deviceStatus(Integer deviceStatus){
-	    setDeviceStatus(deviceStatus);
-		return this;
-    }
-	
-	 /**
-    * 设置 开始 设备状态 (0.未激活，1.离线,2.在线)
-    * @param deviceStatusStart
-    */
+        setDeviceStatus(deviceStatus);
+        return this;
+    }
+
+    /**
+     * 设置 开始 设备状态 (0.未激活，1.离线,2.在线)
+     * @param deviceStatusStart
+     */
     public DeviceQuery deviceStatusStart(Integer deviceStatusStart){
-		this.deviceStatusStart = deviceStatusStart;
-		return this;
+        this.deviceStatusStart = deviceStatusStart;
+        return this;
     }
 
     /**
-    * 设置 结束 设备状态 (0.未激活，1.离线,2.在线)
-    * @param deviceStatusEnd
-    */
+     * 设置 结束 设备状态 (0.未激活，1.离线,2.在线)
+     * @param deviceStatusEnd
+     */
     public DeviceQuery deviceStatusEnd(Integer deviceStatusEnd){
-		this.deviceStatusEnd = deviceStatusEnd;
-		return this;
+        this.deviceStatusEnd = deviceStatusEnd;
+        return this;
     }
 
     /**
-    * 设置 增加 设备状态 (0.未激活，1.离线,2.在线)
-    * @param deviceStatusIncrement
-    */
+     * 设置 增加 设备状态 (0.未激活，1.离线,2.在线)
+     * @param deviceStatusIncrement
+     */
     public DeviceQuery deviceStatusIncrement(Integer deviceStatusIncrement){
-		this.deviceStatusIncrement = deviceStatusIncrement;
-		return this;
+        this.deviceStatusIncrement = deviceStatusIncrement;
+        return this;
     }
 
     /**
-    * 设置 设备状态 (0.未激活，1.离线,2.在线)
-    * @param deviceStatusList
-    */
+     * 设置 设备状态 (0.未激活，1.离线,2.在线)
+     * @param deviceStatusList
+     */
     public DeviceQuery deviceStatusList(List<Integer> deviceStatusList){
         this.deviceStatusList = deviceStatusList;
-		return this;
-        }
-
-        /**
-        * 设置 设备状态 (0.未激活，1.离线,2.在线)
-        * @param deviceStatusNotList
-        */
-        public DeviceQuery deviceStatusNotList(List<Integer> deviceStatusNotList){
+        return this;
+    }
+
+    /**
+     * 设置 设备状态 (0.未激活，1.离线,2.在线)
+     * @param deviceStatusNotList
+     */
+    public DeviceQuery deviceStatusNotList(List<Integer> deviceStatusNotList){
         this.deviceStatusNotList = deviceStatusNotList;
         return this;
-        }
+    }
 
 
-	/**
-    * 设置 备注
-    * @param deviceRemark
-    */
+    /**
+     * 设置 备注
+     * @param deviceRemark
+     */
     public DeviceQuery deviceRemark(String deviceRemark){
         setDeviceRemark(deviceRemark);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 备注
-    * @param deviceRemarkList
-    */
+     * 设置 备注
+     * @param deviceRemarkList
+     */
     public DeviceQuery deviceRemarkList(List<String> deviceRemarkList){
         this.deviceRemarkList = deviceRemarkList;
-		return this;
+        return this;
     }
 
     /**
-    * 设置  设备来源(0.旧设备，1.新设备)
-    * @param source
-    */
+     * 设置  设备来源(0.旧设备，1.新设备)
+     * @param source
+     */
     public DeviceQuery source(Integer source){
-	    setSource(source);
-		return this;
-    }
-	
-	 /**
-    * 设置 开始 设备来源(0.旧设备，1.新设备)
-    * @param sourceStart
-    */
+        setSource(source);
+        return this;
+    }
+
+    /**
+     * 设置 开始 设备来源(0.旧设备，1.新设备)
+     * @param sourceStart
+     */
     public DeviceQuery sourceStart(Integer sourceStart){
-		this.sourceStart = sourceStart;
-		return this;
+        this.sourceStart = sourceStart;
+        return this;
     }
 
     /**
-    * 设置 结束 设备来源(0.旧设备，1.新设备)
-    * @param sourceEnd
-    */
+     * 设置 结束 设备来源(0.旧设备，1.新设备)
+     * @param sourceEnd
+     */
     public DeviceQuery sourceEnd(Integer sourceEnd){
-		this.sourceEnd = sourceEnd;
-		return this;
+        this.sourceEnd = sourceEnd;
+        return this;
     }
 
     /**
-    * 设置 增加 设备来源(0.旧设备，1.新设备)
-    * @param sourceIncrement
-    */
+     * 设置 增加 设备来源(0.旧设备，1.新设备)
+     * @param sourceIncrement
+     */
     public DeviceQuery sourceIncrement(Integer sourceIncrement){
-		this.sourceIncrement = sourceIncrement;
-		return this;
+        this.sourceIncrement = sourceIncrement;
+        return this;
     }
 
     /**
-    * 设置 设备来源(0.旧设备，1.新设备)
-    * @param sourceList
-    */
+     * 设置 设备来源(0.旧设备，1.新设备)
+     * @param sourceList
+     */
     public DeviceQuery sourceList(List<Integer> sourceList){
         this.sourceList = sourceList;
-		return this;
-        }
-
-        /**
-        * 设置 设备来源(0.旧设备，1.新设备)
-        * @param sourceNotList
-        */
-        public DeviceQuery sourceNotList(List<Integer> sourceNotList){
+        return this;
+    }
+
+    /**
+     * 设置 设备来源(0.旧设备，1.新设备)
+     * @param sourceNotList
+     */
+    public DeviceQuery sourceNotList(List<Integer> sourceNotList){
         this.sourceNotList = sourceNotList;
         return this;
-        }
+    }
 
     /**
-    * 设置  创建用户
-    * @param createUserId
-    */
+     * 设置  创建用户
+     * @param createUserId
+     */
     public DeviceQuery createUserId(Long createUserId){
-	    setCreateUserId(createUserId);
-		return this;
-    }
-	
-	 /**
-    * 设置 开始 创建用户
-    * @param createUserIdStart
-    */
+        setCreateUserId(createUserId);
+        return this;
+    }
+
+    /**
+     * 设置 开始 创建用户
+     * @param createUserIdStart
+     */
     public DeviceQuery createUserIdStart(Long createUserIdStart){
-		this.createUserIdStart = createUserIdStart;
-		return this;
+        this.createUserIdStart = createUserIdStart;
+        return this;
     }
 
     /**
-    * 设置 结束 创建用户
-    * @param createUserIdEnd
-    */
+     * 设置 结束 创建用户
+     * @param createUserIdEnd
+     */
     public DeviceQuery createUserIdEnd(Long createUserIdEnd){
-		this.createUserIdEnd = createUserIdEnd;
-		return this;
+        this.createUserIdEnd = createUserIdEnd;
+        return this;
     }
 
     /**
-    * 设置 增加 创建用户
-    * @param createUserIdIncrement
-    */
+     * 设置 增加 创建用户
+     * @param createUserIdIncrement
+     */
     public DeviceQuery createUserIdIncrement(Long createUserIdIncrement){
-		this.createUserIdIncrement = createUserIdIncrement;
-		return this;
+        this.createUserIdIncrement = createUserIdIncrement;
+        return this;
     }
 
     /**
-    * 设置 创建用户
-    * @param createUserIdList
-    */
+     * 设置 创建用户
+     * @param createUserIdList
+     */
     public DeviceQuery createUserIdList(List<Long> createUserIdList){
         this.createUserIdList = createUserIdList;
-		return this;
-        }
-
-        /**
-        * 设置 创建用户
-        * @param createUserIdNotList
-        */
-        public DeviceQuery createUserIdNotList(List<Long> createUserIdNotList){
+        return this;
+    }
+
+    /**
+     * 设置 创建用户
+     * @param createUserIdNotList
+     */
+    public DeviceQuery createUserIdNotList(List<Long> createUserIdNotList){
         this.createUserIdNotList = createUserIdNotList;
         return this;
-        }
+    }
 
 
     /**
-    * 设置  更新用户
-    * @param updateUserId
-    */
+     * 设置  更新用户
+     * @param updateUserId
+     */
     public DeviceQuery updateUserId(Long updateUserId){
-	    setUpdateUserId(updateUserId);
-		return this;
-    }
-	
-	 /**
-    * 设置 开始 更新用户
-    * @param updateUserIdStart
-    */
+        setUpdateUserId(updateUserId);
+        return this;
+    }
+
+    /**
+     * 设置 开始 更新用户
+     * @param updateUserIdStart
+     */
     public DeviceQuery updateUserIdStart(Long updateUserIdStart){
-		this.updateUserIdStart = updateUserIdStart;
-		return this;
+        this.updateUserIdStart = updateUserIdStart;
+        return this;
     }
 
     /**
-    * 设置 结束 更新用户
-    * @param updateUserIdEnd
-    */
+     * 设置 结束 更新用户
+     * @param updateUserIdEnd
+     */
     public DeviceQuery updateUserIdEnd(Long updateUserIdEnd){
-		this.updateUserIdEnd = updateUserIdEnd;
-		return this;
+        this.updateUserIdEnd = updateUserIdEnd;
+        return this;
     }
 
     /**
-    * 设置 增加 更新用户
-    * @param updateUserIdIncrement
-    */
+     * 设置 增加 更新用户
+     * @param updateUserIdIncrement
+     */
     public DeviceQuery updateUserIdIncrement(Long updateUserIdIncrement){
-		this.updateUserIdIncrement = updateUserIdIncrement;
-		return this;
+        this.updateUserIdIncrement = updateUserIdIncrement;
+        return this;
     }
 
     /**
-    * 设置 更新用户
-    * @param updateUserIdList
-    */
+     * 设置 更新用户
+     * @param updateUserIdList
+     */
     public DeviceQuery updateUserIdList(List<Long> updateUserIdList){
         this.updateUserIdList = updateUserIdList;
-		return this;
-        }
-
-        /**
-        * 设置 更新用户
-        * @param updateUserIdNotList
-        */
-        public DeviceQuery updateUserIdNotList(List<Long> updateUserIdNotList){
+        return this;
+    }
+
+    /**
+     * 设置 更新用户
+     * @param updateUserIdNotList
+     */
+    public DeviceQuery updateUserIdNotList(List<Long> updateUserIdNotList){
         this.updateUserIdNotList = updateUserIdNotList;
         return this;
-        }
+    }
+
+
+    /**
+     * 设置  设备生产厂商ID
+     * @param deviceFirmId
+     */
+    public DeviceQuery deviceFirmId(Long deviceFirmId){
+        setDeviceFirmId(deviceFirmId);
+        return this;
+    }
+
+    /**
+     * 设置 开始 设备生产厂商ID
+     * @param deviceFirmIdStart
+     */
+    public DeviceQuery deviceFirmIdStart(Long deviceFirmIdStart){
+        this.deviceFirmIdStart = deviceFirmIdStart;
+        return this;
+    }
+
+    /**
+     * 设置 结束 设备生产厂商ID
+     * @param deviceFirmIdEnd
+     */
+    public DeviceQuery deviceFirmIdEnd(Long deviceFirmIdEnd){
+        this.deviceFirmIdEnd = deviceFirmIdEnd;
+        return this;
+    }
+
+    /**
+     * 设置 增加 设备生产厂商ID
+     * @param deviceFirmIdIncrement
+     */
+    public DeviceQuery deviceFirmIdIncrement(Long deviceFirmIdIncrement){
+        this.deviceFirmIdIncrement = deviceFirmIdIncrement;
+        return this;
+    }
+
+    /**
+     * 设置 设备生产厂商ID
+     * @param deviceFirmIdList
+     */
+    public DeviceQuery deviceFirmIdList(List<Long> deviceFirmIdList){
+        this.deviceFirmIdList = deviceFirmIdList;
+        return this;
+    }
+
+    /**
+     * 设置 设备生产厂商ID
+     * @param deviceFirmIdNotList
+     */
+    public DeviceQuery deviceFirmIdNotList(List<Long> deviceFirmIdNotList){
+        this.deviceFirmIdNotList = deviceFirmIdNotList;
+        return this;
+    }
+
+
+    /**
+     * 设置 设备生产厂商名称
+     * @param deviceFirmname
+     */
+    public DeviceQuery deviceFirmname(String deviceFirmname){
+        setDeviceFirmname(deviceFirmname);
+        return this;
+    }
+
+    /**
+     * 设置 设备生产厂商名称
+     * @param deviceFirmnameList
+     */
+    public DeviceQuery deviceFirmnameList(List<String> deviceFirmnameList){
+        this.deviceFirmnameList = deviceFirmnameList;
+        return this;
+    }
+
+
+    /**
+     * 设置 设备访问ip
+     * @param ip
+     */
+    public DeviceQuery ip(String ip){
+        setIp(ip);
+        return this;
+    }
+
+    /**
+     * 设置 设备访问ip
+     * @param ipList
+     */
+    public DeviceQuery ipList(List<String> ipList){
+        this.ipList = ipList;
+        return this;
+    }
+
+
+    /**
+     * 设置 端口
+     * @param port
+     */
+    public DeviceQuery port(String port){
+        setPort(port);
+        return this;
+    }
+
+    /**
+     * 设置 端口
+     * @param portList
+     */
+    public DeviceQuery portList(List<String> portList){
+        this.portList = portList;
+        return this;
+    }
+
+    /**
+     * 设置  启用状态 (0.停止，1.启用)
+     * @param enabled
+     */
+    public DeviceQuery enabled(Integer enabled){
+        setEnabled(enabled);
+        return this;
+    }
+
+    /**
+     * 设置 开始 启用状态 (0.停止，1.启用)
+     * @param enabledStart
+     */
+    public DeviceQuery enabledStart(Integer enabledStart){
+        this.enabledStart = enabledStart;
+        return this;
+    }
+
+    /**
+     * 设置 结束 启用状态 (0.停止，1.启用)
+     * @param enabledEnd
+     */
+    public DeviceQuery enabledEnd(Integer enabledEnd){
+        this.enabledEnd = enabledEnd;
+        return this;
+    }
+
+    /**
+     * 设置 增加 启用状态 (0.停止，1.启用)
+     * @param enabledIncrement
+     */
+    public DeviceQuery enabledIncrement(Integer enabledIncrement){
+        this.enabledIncrement = enabledIncrement;
+        return this;
+    }
+
+    /**
+     * 设置 启用状态 (0.停止，1.启用)
+     * @param enabledList
+     */
+    public DeviceQuery enabledList(List<Integer> enabledList){
+        this.enabledList = enabledList;
+        return this;
+    }
+
+    /**
+     * 设置 启用状态 (0.停止，1.启用)
+     * @param enabledNotList
+     */
+    public DeviceQuery enabledNotList(List<Integer> enabledNotList){
+        this.enabledNotList = enabledNotList;
+        return this;
+    }
+
 
 
     /**
-    * 获取 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
-    * @return orConditionList
-    */
+     * 获取 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
+     * @return orConditionList
+     */
     public List<DeviceQuery> getOrConditionList(){
-    return this.orConditionList;
+        return this.orConditionList;
     }
 
     /**
-    * 设置 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
-    * @param orConditionList
-    */
+     * 设置 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
+     * @param orConditionList
+     */
     public void setOrConditionList(List<DeviceQuery> orConditionList){
         this.orConditionList = orConditionList;
     }
 
     /**
-    * 获取 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
-    * @return andConditionList
-    */
+     * 获取 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
+     * @return andConditionList
+     */
     public List<DeviceQuery> getAndConditionList(){
         return this.andConditionList;
     }
 
     /**
-    * 设置 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
-    * @param andConditionList
-    */
+     * 设置 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
+     * @param andConditionList
+     */
     public void setAndConditionList(List<DeviceQuery> andConditionList){
         this.andConditionList = andConditionList;
     }

sample-form-manager/src/main/java/com/mortals/xhx/module/device/service/DeviceService.java

 package com.mortals.xhx.module.device.service;
+import com.mortals.framework.model.Context;
 import com.mortals.framework.service.ICRUDService;
+import com.mortals.xhx.module.device.dao.DeviceDao;
 import com.mortals.xhx.module.device.model.DeviceEntity;
 /**
 * DeviceService
@@ -11,4 +13,20 @@ import com.mortals.xhx.module.device.model.DeviceEntity;
 */
 public interface DeviceService extends ICRUDService<DeviceEntity,Long>{
 
+    DeviceDao getDao();
+
+
+    /**
+     * 设备激活
+     * @param deviceCode
+     * @param context
+     */
+    void active(String deviceCode, Context context);
+
+    /**
+     * 设备启用停用
+     * @param id
+     * @param context
+     */
+    void deviceEnabled(Long id, Integer status, Context context);
 }
\ No newline at end of file

sample-form-manager/src/main/java/com/mortals/xhx/module/device/service/impl/DeviceServiceImpl.java

 package com.mortals.xhx.module.device.service.impl;
 
+import com.alibaba.fastjson.JSON;
+import com.mortals.framework.common.Rest;
+import com.mortals.framework.exception.AppException;
+import com.mortals.framework.model.Context;
 import com.mortals.framework.service.impl.AbstractCRUDServiceImpl;
+import com.mortals.xhx.common.code.DeviceMethodEnum;
+import com.mortals.xhx.common.code.DeviceStatusEnum;
+import com.mortals.xhx.common.code.EnabledEnum;
+import com.mortals.xhx.common.pdu.LoginForm;
+import com.mortals.xhx.common.pdu.device.DeviceReq;
+import com.mortals.xhx.feign.device.IDeviceFeign;
 import com.mortals.xhx.module.device.dao.DeviceDao;
 import com.mortals.xhx.module.device.model.DeviceEntity;
+import com.mortals.xhx.module.device.model.DeviceQuery;
 import com.mortals.xhx.module.device.service.DeviceService;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Service;
+import org.springframework.util.ObjectUtils;
+
+import java.util.Date;
+
 /**
 * DeviceService
 * 设备 service实现
@@ -13,6 +31,58 @@ import org.springframework.stereotype.Service;
 * @date 2023-02-25
 */
 @Service("deviceService")
+@Slf4j
 public class DeviceServiceImpl extends AbstractCRUDServiceImpl<DeviceDao, DeviceEntity, Long> implements DeviceService {
 
+    @Autowired
+    private IDeviceFeign deviceFeign;
+    @Value("${token.loginName:'admin'}")
+    private String loginName;
+    @Value("${token.password:'admin'}")
+    private String password;
+
+
+    @Override
+    public void active(String deviceCode, Context context) {
+        DeviceEntity deviceEntity = this.selectOne(new DeviceQuery().deviceCode(deviceCode));
+        if (ObjectUtils.isEmpty(deviceEntity)) throw new AppException("当前设备不存在！");
+        if (deviceEntity.getDeviceStatus() > DeviceStatusEnum.未激活.getValue())
+            throw new AppException("当前设备已激活！");
+        deviceEntity.setDeviceStatus(DeviceStatusEnum.离线.getValue());
+        deviceEntity.setEnabled(EnabledEnum.启用.getValue());
+        this.getDao().update(deviceEntity);
+
+        String token = getToken();
+        DeviceReq deviceReq = new DeviceReq();
+        deviceReq.setReceiveMethod(DeviceMethodEnum.ACTIVE.getValue());
+        deviceReq.setDeviceCode(deviceCode);
+        Rest<String> rest = deviceFeign.deviceCall(deviceReq, token);
+        log.info("激活结果：{}", JSON.toJSONString(rest));
+    }
+
+    @Override
+    public void deviceEnabled(Long id, Integer enabled, Context context) {
+        DeviceEntity deviceEntity = this.get(id, context);
+        if (ObjectUtils.isEmpty(deviceEntity)) throw new AppException("当前设备不存在！");
+        deviceEntity.setEnabled(enabled);
+        deviceEntity.setUpdateTime(new Date());
+        deviceEntity.setUpdateUserId(getContextUserId(context));
+        this.getDao().update(deviceEntity);
+        String token = getToken();
+        DeviceReq deviceReq = new DeviceReq();
+        deviceReq.setReceiveMethod(DeviceMethodEnum.ENABLED.getValue());
+        deviceReq.setDeviceCode(deviceEntity.getDeviceCode());
+        Rest<String> rest = deviceFeign.deviceCall(deviceReq, token);
+        log.info("启用结果：{}", JSON.toJSONString(rest));
+    }
+
+
+    private String getToken() {
+        LoginForm loginForm = new LoginForm();
+        loginForm.setLoginName(loginName);
+        loginForm.setPassword(password);
+        Rest<String> rest = deviceFeign.getToken(loginForm);
+        String token = rest.getData();
+        return token;
+    }
 }
\ No newline at end of file

sample-form-manager/src/main/java/com/mortals/xhx/module/device/web/DeviceController.java

 package com.mortals.xhx.module.device.web;
+
+import com.alibaba.fastjson.JSON;
+import com.mortals.framework.common.Rest;
+import com.mortals.framework.exception.AppException;
 import com.mortals.framework.web.BaseCRUDJsonBodyMappingController;
 import com.mortals.xhx.base.system.param.service.ParamService;
+import com.mortals.xhx.common.code.DeviceMethodEnum;
+import com.mortals.xhx.common.code.EnabledEnum;
+import com.mortals.xhx.common.pdu.LoginForm;
+import com.mortals.xhx.common.pdu.device.DeviceReq;
+import com.mortals.xhx.feign.device.IDeviceFeign;
+import com.mortals.xhx.module.device.model.DeviceQuery;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.ObjectUtils;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;
 import org.springframework.web.bind.annotation.*;
 import com.mortals.framework.model.Context;
+
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
+
 import com.mortals.framework.web.BaseCRUDJsonBodyMappingController;
 import com.mortals.xhx.module.device.model.DeviceEntity;
 import com.mortals.xhx.module.device.service.DeviceService;
 import org.apache.commons.lang3.ArrayUtils;
 import com.mortals.framework.util.StringUtils;
+
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.stream.Collectors;
+
 import com.alibaba.fastjson.JSONObject;
+
 import java.util.Arrays;
+
 import org.springframework.web.bind.annotation.*;
 import org.springframework.web.multipart.MultipartFile;
+
 import static com.mortals.framework.ap.SysConstains.*;
+
 /**
-*
-* 设备
-*
-* @author zxfei
-* @date 2023-02-25
-*/
+ * 设备
+ *
+ * @author zxfei
+ * @date 2023-02-25
+ */
 @RestController
 @RequestMapping("device")
-public class DeviceController extends BaseCRUDJsonBodyMappingController<DeviceService,DeviceEntity,Long> {
+@Slf4j
+public class DeviceController extends BaseCRUDJsonBodyMappingController<DeviceService, DeviceEntity, Long> {
 
     @Autowired
     private ParamService paramService;
 
-    public DeviceController(){
-        super.setModuleDesc( "设备");
+    @Autowired
+    private IDeviceFeign deviceFeign;
+    @Value("${token.loginName:'admin'}")
+    private String loginName;
+    @Value("${token.password:'admin'}")
+    private String password;
+
+    public DeviceController() {
+        super.setModuleDesc("设备");
     }
 
     @Override
     protected void init(Map<String, Object> model, Context context) {
-        this.addDict(model, "deviceSrc", paramService.getParamBySecondOrganize("Device","deviceSrc"));
-        this.addDict(model, "deviceStatus", paramService.getParamBySecondOrganize("Device","deviceStatus"));
-        this.addDict(model, "source", paramService.getParamBySecondOrganize("Device","source"));
+        this.addDict(model, "deviceSrc", paramService.getParamBySecondOrganize("Device", "deviceSrc"));
+        this.addDict(model, "deviceStatus", paramService.getParamBySecondOrganize("Device", "deviceStatus"));
+        this.addDict(model, "source", paramService.getParamBySecondOrganize("Device", "source"));
+        this.addDict(model, "enabled", EnabledEnum.getEnumMap());
         super.init(model, context);
     }
 
 
+    /**
+     * 设备激活
+     */
+    @PostMapping(value = "active")
+    public Rest<Void> deviceActive(@RequestBody DeviceEntity deviceEntity) {
+        log.info("设备激活：{}", deviceEntity.getDeviceCode());
+        String busiDesc = this.getModuleDesc() + "设备激活";
+        Rest<Void> rest = Rest.ok(busiDesc + " 【成功】");
+        try {
+            this.service.active(deviceEntity.getDeviceCode(), getContext());
+            recordSysLog(request, busiDesc + " 【成功】");
+        } catch (Exception e) {
+            log.error("设备激活消息", e);
+            rest = Rest.fail(super.convertException(e));
+        }
+        return rest;
+    }
+
+    /**
+     * 设备启用停用
+     */
+    @PostMapping(value = "enable")
+    public String deviceEnable(@RequestBody DeviceEntity deviceEntity) {
+        JSONObject jsonObject = new JSONObject();
+        Map<String, Object> model = new HashMap<>();
+        String busiDesc = this.getModuleDesc() + "设备";
+        try {
+            this.service.deviceEnabled(deviceEntity.getId(), deviceEntity.getEnabled(), getContext());
+            recordSysLog(request, busiDesc + EnabledEnum.getByValue(deviceEntity.getEnabled()).getDesc() + " 【成功】");
+            jsonObject.put(KEY_RESULT_DATA, model);
+            jsonObject.put(KEY_RESULT_CODE, VALUE_RESULT_SUCCESS);
+        } catch (Exception e) {
+            log.error("设备启用停用消息", e);
+            jsonObject.put(KEY_RESULT_CODE, VALUE_RESULT_FAILURE);
+            jsonObject.put(KEY_RESULT_MSG, super.convertException(e));
+        }
+        return jsonObject.toJSONString();
+    }
+
+    @Override
+    protected int saveAfter(DeviceEntity entity, Map<String, Object> model, Context context) throws AppException {
+        if (ObjectUtils.isEmpty(entity.getUpdateTime())) {
+            String token = getToken();
+            DeviceReq deviceReq = new DeviceReq();
+            deviceReq.setReceiveMethod(DeviceMethodEnum.ADD.getValue());
+            deviceReq.setDeviceName(entity.getDeviceName());
+            deviceReq.setDeviceCode(entity.getDeviceCode());
+            deviceReq.setProductCode(entity.getProductCode());
+            deviceReq.setIp(entity.getIp());
+            deviceReq.setPort(entity.getPort());
+            deviceReq.setSiteId(1L);
+            deviceReq.setSiteCode("511500000000-0001");
+            deviceReq.setSiteName("宜宾市民中心");
+            deviceReq.setLeadingOfficial(entity.getLeadingOfficial());
+            deviceReq.setLeadingOfficialTelephone(entity.getLeadingOfficialTelephone());
+            deviceReq.setSource(1);
+            deviceReq.setDeviceStatus(entity.getDeviceStatus());
+            Rest<String> rest = deviceFeign.deviceCall(deviceReq, token);
+            log.info("添加结果：{}", JSON.toJSONString(rest));
+        } else {
+            String token = getToken();
+            DeviceReq deviceReq = new DeviceReq();
+            deviceReq.setReceiveMethod(DeviceMethodEnum.UPDATE.getValue());
+            deviceReq.setDeviceName(entity.getDeviceName());
+            deviceReq.setDeviceCode(entity.getDeviceCode());
+            deviceReq.setProductCode(entity.getProductCode());
+            deviceReq.setIp(entity.getIp());
+            deviceReq.setPort(entity.getPort());
+            deviceReq.setSiteId(1L);
+            deviceReq.setSiteCode("511500000000-0001");
+            deviceReq.setSiteName("宜宾市民中心");
+            deviceReq.setLeadingOfficial(entity.getLeadingOfficial());
+            deviceReq.setLeadingOfficialTelephone(entity.getLeadingOfficialTelephone());
+            deviceReq.setSource(1);
+            deviceReq.setDeviceStatus(entity.getDeviceStatus());
+            Rest<String> rest = deviceFeign.deviceCall(deviceReq, token);
+            log.info("更新结果：{}", JSON.toJSONString(rest));
+        }
+
+        return super.saveAfter(entity, model, context);
+    }
+
+    @Override
+    protected void deleteBefore(Long[] ids, Context context) throws AppException {
+        super.deleteBefore(ids, context);
+        String token = getToken();
+        DeviceQuery deviceQuery = new DeviceQuery();
+        deviceQuery.setIdList(Arrays.asList(ids));
+        List<DeviceEntity> deviceEntities = this.service.find(deviceQuery, context);
+        for (DeviceEntity entity : deviceEntities) {
+            DeviceReq deviceReq = new DeviceReq();
+            deviceReq.setReceiveMethod(DeviceMethodEnum.DEL.getValue());
+            deviceReq.setDeviceCode(entity.getDeviceCode());
+            Rest<String> rest = deviceFeign.deviceCall(deviceReq, token);
+            log.info("删除结果：{}", JSON.toJSONString(rest));
+        }
+    }
+
+    private String getToken() {
+        LoginForm loginForm = new LoginForm();
+        loginForm.setLoginName(loginName);
+        loginForm.setPassword(password);
+        Rest<String> rest = deviceFeign.getToken(loginForm);
+        String token = rest.getData();
+        return token;
+    }
+
 }
\ No newline at end of file