Skip to content

F
fill-system
Commit 090cf87b authored by 赵啸非's avatar 赵啸非
Browse files
Options

设备添加楼层与楼栋

parent b14277d8
Pipeline #2739 failed with stages
      Show whitespace changes
      Inline Side-by-side
      Showing with 1674 additions and 997 deletions
      fill-manager/db/add.sql
      View file @ 090cf87b
      ......@@ -37,3 +37,12 @@ ALTER TABLE mortals_xhx_device
      ADD COLUMN `onlineTime` datetime DEFAULT NULL COMMENT '最近上线时间' AFTER enabled;
      ALTER TABLE mortals_xhx_device
      ADD COLUMN `offlineTime` datetime DEFAULT NULL COMMENT '最近离线时间' AFTER onlineTime;
      -- ----------------------------
      2024-01-15
      -- ----------------------------
      ALTER TABLE mortals_xhx_device
      ADD COLUMN `deviceInBuilding` tinyint(4) COMMENT '所属楼栋';
      ALTER TABLE mortals_xhx_device
      ADD COLUMN `deviceInFloor` tinyint(4) COMMENT '所属楼层';
      \ No newline at end of file
      fill-manager/src/main/java/com/mortals/xhx/module/device/model/DeviceEntity.java
      View file @ 090cf87b
      ......@@ -2,6 +2,9 @@ package com.mortals.xhx.module.device.model;
      import java.util.Date;
      import java.util.List;
      import java.util.ArrayList;
      import java.math.BigDecimal;
      import cn.hutool.core.date.DateUtil;
      import java.util.Date;
      import com.fasterxml.jackson.annotation.JsonFormat;
      import com.mortals.framework.annotation.Excel;
      import com.mortals.framework.model.BaseEntityLong;
      ......@@ -11,7 +14,7 @@ import lombok.Data;
      * 设备实体对象
      *
      * @author zxfei
      * @date 2023-06-21
      * @date 2024-01-15
      */
      @Data
      public class DeviceEntity extends DeviceVo {
      ......@@ -45,6 +48,26 @@ public class DeviceEntity extends DeviceVo {
      * 站点名称
      */
      private String siteName;
      /**
      * 设备生产厂商ID
      */
      private Long deviceFirmId;
      /**
      * 设备生产厂商名称
      */
      private String deviceFirmname;
      /**
      * 设备访问ip
      */
      private String ip;
      /**
      * 端口
      */
      private String port;
      /**
      * 启用状态 (0.停止，1.启用)
      */
      private Integer enabled;
      /**
      * 产品编码
      */
      ......@@ -82,29 +105,17 @@ public class DeviceEntity extends DeviceVo {
      */
      private String deviceRemark;
      /**
      * 设备来源(0.旧设备，1.新设备)
      * 所属机构
      */
      private Integer source;
      private String belong;
      /**
      * 设备生产厂商ID
      * 所属楼栋
      */
      private Long deviceFirmId;
      private Integer deviceInBuilding;
      /**
      * 设备生产厂商名称
      * 所属楼层
      */
      private String deviceFirmname;
      /**
      * 设备访问ip
      */
      private String ip;
      /**
      * 端口
      */
      private String port;
      /**
      * 启用状态 (0.停止，1.启用)
      */
      private Integer enabled;
      private Integer deviceInFloor;
      /**
      * 最近上线时间
      */
      ......@@ -113,6 +124,10 @@ public class DeviceEntity extends DeviceVo {
      * 最近离线时间
      */
      private Date offlineTime;
      /**
      * 设备来源(0.旧设备，1.新设备)
      */
      private Integer source;
      @Override
      public int hashCode() {
      return this.getId().hashCode();
      ......@@ -130,53 +145,32 @@ public class DeviceEntity extends DeviceVo {
      }
      public void initAttrValue(){
      this.deviceId = -1L;
      this.deviceId = null;
      this.deviceName = "";
      this.deviceCode = "";
      this.deviceMac = "";
      this.siteId = -1L;
      this.siteId = null;
      this.siteCode = "";
      this.siteName = "";
      this.deviceFirmId = null;
      this.deviceFirmname = "";
      this.ip = "";
      this.port = "";
      this.enabled = 0;
      this.productCode = "";
      this.productName = "";
      this.deviceSrc = 2;
      this.lon = "";
      this.lati = "";
      this.leadingOfficial = "";
      this.leadingOfficialTelephone = "";
      this.deviceStatus = 0;
      this.deviceRemark = "";
      this.belong = "";
      this.deviceInBuilding = 0;
      this.deviceInFloor = 0;
      this.onlineTime = new Date();
      this.offlineTime = new Date();
      this.source = 1;
      this.deviceFirmId = -1L;
      this.deviceFirmname = "";
      this.ip = "";
      this.port = "";
      this.enabled = 0;
      this.onlineTime = null;
      this.offlineTime = null;
      }
      }
      \ No newline at end of file
      fill-manager/src/main/java/com/mortals/xhx/module/device/model/DeviceQuery.java
      View file @ 090cf87b
      ......@@ -7,7 +7,7 @@ import com.mortals.xhx.module.device.model.DeviceEntity;
      * 设备查询对象
      *
      * @author zxfei
      * @date 2023-06-21
      * @date 2024-01-15
      */
      public class DeviceQuery extends DeviceEntity {
      /** 开始 主键ID，主键，自增长 */
      ......@@ -80,6 +80,51 @@ public class DeviceQuery extends DeviceEntity {
      /** 站点名称排除列表 */
      private List <String> siteNameNotList;
      /** 开始 设备生产厂商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 List<String> productCodeList;
      ......@@ -145,6 +190,53 @@ public class DeviceQuery extends DeviceEntity {
      /** 备注排除列表 */
      private List <String> deviceRemarkNotList;
      /** 所属机构 */
      private List<String> belongList;
      /** 所属机构排除列表 */
      private List <String> belongNotList;
      /** 开始 所属楼栋 */
      private Integer deviceInBuildingStart;
      /** 结束 所属楼栋 */
      private Integer deviceInBuildingEnd;
      /** 增加 所属楼栋 */
      private Integer deviceInBuildingIncrement;
      /** 所属楼栋列表 */
      private List <Integer> deviceInBuildingList;
      /** 所属楼栋排除列表 */
      private List <Integer> deviceInBuildingNotList;
      /** 开始 所属楼层 */
      private Integer deviceInFloorStart;
      /** 结束 所属楼层 */
      private Integer deviceInFloorEnd;
      /** 增加 所属楼层 */
      private Integer deviceInFloorIncrement;
      /** 所属楼层列表 */
      private List <Integer> deviceInFloorList;
      /** 所属楼层排除列表 */
      private List <Integer> deviceInFloorNotList;
      /** 开始 最近上线时间 */
      private String onlineTimeStart;
      /** 结束 最近上线时间 */
      private String onlineTimeEnd;
      /** 开始 最近离线时间 */
      private String offlineTimeStart;
      /** 结束 最近离线时间 */
      private String offlineTimeEnd;
      /** 开始 设备来源(0.旧设备，1.新设备) */
      private Integer sourceStart;
      ......@@ -202,63 +294,6 @@ 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;
      ......@@ -671,136 +706,394 @@ public class DeviceQuery extends DeviceEntity {
      }
      /**
      * 获取 产品编码
      * @return productCodeList
      * 获取 开始 设备生产厂商ID
      * @return deviceFirmIdStart
      */
      public List<String> getProductCodeList(){
      return this.productCodeList;
      public Long getDeviceFirmIdStart(){
      return this.deviceFirmIdStart;
      }
      /**
      * 设置 产品编码
      * @param productCodeList
      * 设置 开始 设备生产厂商ID
      * @param deviceFirmIdStart
      */
      public void setProductCodeList(List<String> productCodeList){
      this.productCodeList = productCodeList;
      public void setDeviceFirmIdStart(Long deviceFirmIdStart){
      this.deviceFirmIdStart = deviceFirmIdStart;
      }
      /**
      * 获取 产品编码
      * @return productCodeNotList
      * 获取 结束 设备生产厂商ID
      * @return $deviceFirmIdEnd
      */
      public List<String> getProductCodeNotList(){
      return this.productCodeNotList;
      public Long getDeviceFirmIdEnd(){
      return this.deviceFirmIdEnd;
      }
      /**
      * 设置 产品编码
      * @param productCodeNotList
      * 设置 结束 设备生产厂商ID
      * @param deviceFirmIdEnd
      */
      public void setProductCodeNotList(List<String> productCodeNotList){
      this.productCodeNotList = productCodeNotList;
      public void setDeviceFirmIdEnd(Long deviceFirmIdEnd){
      this.deviceFirmIdEnd = deviceFirmIdEnd;
      }
      /**
      * 获取 产品名称
      * @return productNameList
      * 获取 增加 设备生产厂商ID
      * @return deviceFirmIdIncrement
      */
      public List<String> getProductNameList(){
      return this.productNameList;
      public Long getDeviceFirmIdIncrement(){
      return this.deviceFirmIdIncrement;
      }
      /**
      * 设置 产品名称
      * @param productNameList
      * 设置 增加 设备生产厂商ID
      * @param deviceFirmIdIncrement
      */
      public void setProductNameList(List<String> productNameList){
      this.productNameList = productNameList;
      public void setDeviceFirmIdIncrement(Long deviceFirmIdIncrement){
      this.deviceFirmIdIncrement = deviceFirmIdIncrement;
      }
      /**
      * 获取 产品名称
      * @return productNameNotList
      * 获取 设备生产厂商ID
      * @return deviceFirmIdList
      */
      public List<String> getProductNameNotList(){
      return this.productNameNotList;
      public List<Long> getDeviceFirmIdList(){
      return this.deviceFirmIdList;
      }
      /**
      * 设置 产品名称
      * @param productNameNotList
      * 设置 设备生产厂商ID
      * @param deviceFirmIdList
      */
      public void setProductNameNotList(List<String> productNameNotList){
      this.productNameNotList = productNameNotList;
      public void setDeviceFirmIdList(List<Long> deviceFirmIdList){
      this.deviceFirmIdList = deviceFirmIdList;
      }
      /**
      * 获取 开始 设备来源(0.子设备，1.网关设备，2.直连设备)
      * @return deviceSrcStart
      * 获取 设备生产厂商ID
      * @return deviceFirmIdNotList
      */
      public Integer getDeviceSrcStart(){
      return this.deviceSrcStart;
      public List<Long> getDeviceFirmIdNotList(){
      return this.deviceFirmIdNotList;
      }
      /**
      * 设置 开始 设备来源(0.子设备，1.网关设备，2.直连设备)
      * @param deviceSrcStart
      * 设置 设备生产厂商ID
      * @param deviceFirmIdNotList
      */
      public void setDeviceSrcStart(Integer deviceSrcStart){
      this.deviceSrcStart = deviceSrcStart;
      public void setDeviceFirmIdNotList(List<Long> deviceFirmIdNotList){
      this.deviceFirmIdNotList = deviceFirmIdNotList;
      }
      /**
      * 获取 结束 设备来源(0.子设备，1.网关设备，2.直连设备)
      * @return $deviceSrcEnd
      * 获取 设备生产厂商名称
      * @return deviceFirmnameList
      */
      public Integer getDeviceSrcEnd(){
      return this.deviceSrcEnd;
      public List<String> getDeviceFirmnameList(){
      return this.deviceFirmnameList;
      }
      /**
      * 设置 结束 设备来源(0.子设备，1.网关设备，2.直连设备)
      * @param deviceSrcEnd
      * 设置 设备生产厂商名称
      * @param deviceFirmnameList
      */
      public void setDeviceSrcEnd(Integer deviceSrcEnd){
      this.deviceSrcEnd = deviceSrcEnd;
      public void setDeviceFirmnameList(List<String> deviceFirmnameList){
      this.deviceFirmnameList = deviceFirmnameList;
      }
      /**
      * 获取 增加 设备来源(0.子设备，1.网关设备，2.直连设备)
      * @return deviceSrcIncrement
      * 获取 设备生产厂商名称
      * @return deviceFirmnameNotList
      */
      public Integer getDeviceSrcIncrement(){
      return this.deviceSrcIncrement;
      public List<String> getDeviceFirmnameNotList(){
      return this.deviceFirmnameNotList;
      }
      /**
      * 设置 增加 设备来源(0.子设备，1.网关设备，2.直连设备)
      * @param deviceSrcIncrement
      * 设置 设备生产厂商名称
      * @param deviceFirmnameNotList
      */
      public void setDeviceSrcIncrement(Integer deviceSrcIncrement){
      this.deviceSrcIncrement = deviceSrcIncrement;
      public void setDeviceFirmnameNotList(List<String> deviceFirmnameNotList){
      this.deviceFirmnameNotList = deviceFirmnameNotList;
      }
      /**
      * 获取 设备来源(0.子设备，1.网关设备，2.直连设备)
      * @return deviceSrcList
      * 获取 设备访问ip
      * @return ipList
      */
      public List<Integer> getDeviceSrcList(){
      return this.deviceSrcList;
      public List<String> getIpList(){
      return this.ipList;
      }
      /**
      * 设置 设备来源(0.子设备，1.网关设备，2.直连设备)
      * @param deviceSrcList
      * 设置 设备访问ip
      * @param ipList
      */
      public void setDeviceSrcList(List<Integer> deviceSrcList){
      this.deviceSrcList = deviceSrcList;
      public void setIpList(List<String> ipList){
      this.ipList = ipList;
      }
      /**
      * 获取 设备来源(0.子设备，1.网关设备，2.直连设备)
      * @return deviceSrcNotList
      * 获取 设备访问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 productCodeList
      */
      public List<String> getProductCodeList(){
      return this.productCodeList;
      }
      /**
      * 设置 产品编码
      * @param productCodeList
      */
      public void setProductCodeList(List<String> productCodeList){
      this.productCodeList = productCodeList;
      }
      /**
      * 获取 产品编码
      * @return productCodeNotList
      */
      public List<String> getProductCodeNotList(){
      return this.productCodeNotList;
      }
      /**
      * 设置 产品编码
      * @param productCodeNotList
      */
      public void setProductCodeNotList(List<String> productCodeNotList){
      this.productCodeNotList = productCodeNotList;
      }
      /**
      * 获取 产品名称
      * @return productNameList
      */
      public List<String> getProductNameList(){
      return this.productNameList;
      }
      /**
      * 设置 产品名称
      * @param productNameList
      */
      public void setProductNameList(List<String> productNameList){
      this.productNameList = productNameList;
      }
      /**
      * 获取 产品名称
      * @return productNameNotList
      */
      public List<String> getProductNameNotList(){
      return this.productNameNotList;
      }
      /**
      * 设置 产品名称
      * @param productNameNotList
      */
      public void setProductNameNotList(List<String> productNameNotList){
      this.productNameNotList = productNameNotList;
      }
      /**
      * 获取 开始 设备来源(0.子设备，1.网关设备，2.直连设备)
      * @return deviceSrcStart
      */
      public Integer getDeviceSrcStart(){
      return this.deviceSrcStart;
      }
      /**
      * 设置 开始 设备来源(0.子设备，1.网关设备，2.直连设备)
      * @param deviceSrcStart
      */
      public void setDeviceSrcStart(Integer deviceSrcStart){
      this.deviceSrcStart = deviceSrcStart;
      }
      /**
      * 获取 结束 设备来源(0.子设备，1.网关设备，2.直连设备)
      * @return $deviceSrcEnd
      */
      public Integer getDeviceSrcEnd(){
      return this.deviceSrcEnd;
      }
      /**
      * 设置 结束 设备来源(0.子设备，1.网关设备，2.直连设备)
      * @param deviceSrcEnd
      */
      public void setDeviceSrcEnd(Integer deviceSrcEnd){
      this.deviceSrcEnd = deviceSrcEnd;
      }
      /**
      * 获取 增加 设备来源(0.子设备，1.网关设备，2.直连设备)
      * @return deviceSrcIncrement
      */
      public Integer getDeviceSrcIncrement(){
      return this.deviceSrcIncrement;
      }
      /**
      * 设置 增加 设备来源(0.子设备，1.网关设备，2.直连设备)
      * @param deviceSrcIncrement
      */
      public void setDeviceSrcIncrement(Integer deviceSrcIncrement){
      this.deviceSrcIncrement = deviceSrcIncrement;
      }
      /**
      * 获取 设备来源(0.子设备，1.网关设备，2.直连设备)
      * @return deviceSrcList
      */
      public List<Integer> getDeviceSrcList(){
      return this.deviceSrcList;
      }
      /**
      * 设置 设备来源(0.子设备，1.网关设备，2.直连设备)
      * @param deviceSrcList
      */
      public void setDeviceSrcList(List<Integer> deviceSrcList){
      this.deviceSrcList = deviceSrcList;
      }
      /**
      * 获取 设备来源(0.子设备，1.网关设备，2.直连设备)
      * @return deviceSrcNotList
      */
      public List<Integer> getDeviceSrcNotList(){
      return this.deviceSrcNotList;
      ......@@ -1057,632 +1350,568 @@ public class DeviceQuery extends DeviceEntity {
      }
      /**
      * 获取 开始 设备来源(0.旧设备，1.新设备)
      * @return sourceStart
      * 获取 所属机构
      * @return belongList
      */
      public Integer getSourceStart(){
      return this.sourceStart;
      public List<String> getBelongList(){
      return this.belongList;
      }
      /**
      * 设置 开始 设备来源(0.旧设备，1.新设备)
      * @param sourceStart
      * 设置 所属机构
      * @param belongList
      */
      public void setSourceStart(Integer sourceStart){
      this.sourceStart = sourceStart;
      public void setBelongList(List<String> belongList){
      this.belongList = belongList;
      }
      /**
      * 获取 结束 设备来源(0.旧设备，1.新设备)
      * @return $sourceEnd
      * 获取 所属机构
      * @return belongNotList
      */
      public Integer getSourceEnd(){
      return this.sourceEnd;
      public List<String> getBelongNotList(){
      return this.belongNotList;
      }
      /**
      * 设置 结束 设备来源(0.旧设备，1.新设备)
      * @param sourceEnd
      * 设置 所属机构
      * @param belongNotList
      */
      public void setSourceEnd(Integer sourceEnd){
      this.sourceEnd = sourceEnd;
      public void setBelongNotList(List<String> belongNotList){
      this.belongNotList = belongNotList;
      }
      /**
      * 获取 增加 设备来源(0.旧设备，1.新设备)
      * @return sourceIncrement
      * 获取 开始 所属楼栋
      * @return deviceInBuildingStart
      */
      public Integer getSourceIncrement(){
      return this.sourceIncrement;
      public Integer getDeviceInBuildingStart(){
      return this.deviceInBuildingStart;
      }
      /**
      * 设置 增加 设备来源(0.旧设备，1.新设备)
      * @param sourceIncrement
      * 设置 开始 所属楼栋
      * @param deviceInBuildingStart
      */
      public void setSourceIncrement(Integer sourceIncrement){
      this.sourceIncrement = sourceIncrement;
      }
      /**
      * 获取 设备来源(0.旧设备，1.新设备)
      * @return sourceList
      */
      public List<Integer> getSourceList(){
      return this.sourceList;
      }
      /**
      * 设置 设备来源(0.旧设备，1.新设备)
      * @param sourceList
      */
      public void setSourceList(List<Integer> sourceList){
      this.sourceList = sourceList;
      }
      /**
      * 获取 设备来源(0.旧设备，1.新设备)
      * @return sourceNotList
      */
      public List<Integer> getSourceNotList(){
      return this.sourceNotList;
      }
      /**
      * 设置 设备来源(0.旧设备，1.新设备)
      * @param sourceNotList
      */
      public void setSourceNotList(List<Integer> sourceNotList){
      this.sourceNotList = sourceNotList;
      }
      /**
      * 获取 开始 创建用户
      * @return createUserIdStart
      */
      public Long getCreateUserIdStart(){
      return this.createUserIdStart;
      }
      /**
      * 设置 开始 创建用户
      * @param createUserIdStart
      */
      public void setCreateUserIdStart(Long createUserIdStart){
      this.createUserIdStart = createUserIdStart;
      }
      /**
      * 获取 结束 创建用户
      * @return $createUserIdEnd
      */
      public Long getCreateUserIdEnd(){
      return this.createUserIdEnd;
      public void setDeviceInBuildingStart(Integer deviceInBuildingStart){
      this.deviceInBuildingStart = deviceInBuildingStart;
      }
      /**
      * 设置 结束 创建用户
      * @param createUserIdEnd
      * 获取 结束 所属楼栋
      * @return $deviceInBuildingEnd
      */
      public void setCreateUserIdEnd(Long createUserIdEnd){
      this.createUserIdEnd = createUserIdEnd;
      public Integer getDeviceInBuildingEnd(){
      return this.deviceInBuildingEnd;
      }
      /**
      * 获取 增加 创建用户
      * @return createUserIdIncrement
      * 设置 结束 所属楼栋
      * @param deviceInBuildingEnd
      */
      public Long getCreateUserIdIncrement(){
      return this.createUserIdIncrement;
      public void setDeviceInBuildingEnd(Integer deviceInBuildingEnd){
      this.deviceInBuildingEnd = deviceInBuildingEnd;
      }
      /**
      * 设置 增加 创建用户
      * @param createUserIdIncrement
      * 获取 增加 所属楼栋
      * @return deviceInBuildingIncrement
      */
      public void setCreateUserIdIncrement(Long createUserIdIncrement){
      this.createUserIdIncrement = createUserIdIncrement;
      public Integer getDeviceInBuildingIncrement(){
      return this.deviceInBuildingIncrement;
      }
      /**
      * 获取 创建用户
      * @return createUserIdList
      * 设置 增加 所属楼栋
      * @param deviceInBuildingIncrement
      */
      public List<Long> getCreateUserIdList(){
      return this.createUserIdList;
      public void setDeviceInBuildingIncrement(Integer deviceInBuildingIncrement){
      this.deviceInBuildingIncrement = deviceInBuildingIncrement;
      }
      /**
      * 设置 创建用户
      * @param createUserIdList
      * 获取 所属楼栋
      * @return deviceInBuildingList
      */
      public void setCreateUserIdList(List<Long> createUserIdList){
      this.createUserIdList = createUserIdList;
      public List<Integer> getDeviceInBuildingList(){
      return this.deviceInBuildingList;
      }
      /**
      * 获取 创建用户
      * @return createUserIdNotList
      * 设置 所属楼栋
      * @param deviceInBuildingList
      */
      public List<Long> getCreateUserIdNotList(){
      return this.createUserIdNotList;
      public void setDeviceInBuildingList(List<Integer> deviceInBuildingList){
      this.deviceInBuildingList = deviceInBuildingList;
      }
      /**
      * 设置 创建用户
      * @param createUserIdNotList
      * 获取 所属楼栋
      * @return deviceInBuildingNotList
      */
      public void setCreateUserIdNotList(List<Long> createUserIdNotList){
      this.createUserIdNotList = createUserIdNotList;
      public List<Integer> getDeviceInBuildingNotList(){
      return this.deviceInBuildingNotList;
      }
      /**
      * 获取 开始 创建时间
      * @return createTimeStart
      * 设置 所属楼栋
      * @param deviceInBuildingNotList
      */
      public String getCreateTimeStart(){
      return this.createTimeStart;
      public void setDeviceInBuildingNotList(List<Integer> deviceInBuildingNotList){
      this.deviceInBuildingNotList = deviceInBuildingNotList;
      }
      /**
      * 设置 开始 创建时间
      * @param createTimeStart
      */
      public void setCreateTimeStart(String createTimeStart){
      this.createTimeStart = createTimeStart;
      }
      /**
      * 获取 结束 创建时间
      * @return createTimeEnd
      * 获取 开始 所属楼层
      * @return deviceInFloorStart
      */
      public String getCreateTimeEnd(){
      return this.createTimeEnd;
      public Integer getDeviceInFloorStart(){
      return this.deviceInFloorStart;
      }
      /**
      * 设置 结束 创建时间
      * @param createTimeEnd
      * 设置 开始 所属楼层
      * @param deviceInFloorStart
      */
      public void setCreateTimeEnd(String createTimeEnd){
      this.createTimeEnd = createTimeEnd;
      public void setDeviceInFloorStart(Integer deviceInFloorStart){
      this.deviceInFloorStart = deviceInFloorStart;
      }
      /**
      * 获取 开始 更新用户
      * @return updateUserIdStart
      * 获取 结束 所属楼层
      * @return $deviceInFloorEnd
      */
      public Long getUpdateUserIdStart(){
      return this.updateUserIdStart;
      public Integer getDeviceInFloorEnd(){
      return this.deviceInFloorEnd;
      }
      /**
      * 设置 开始 更新用户
      * @param updateUserIdStart
      * 设置 结束 所属楼层
      * @param deviceInFloorEnd
      */
      public void setUpdateUserIdStart(Long updateUserIdStart){
      this.updateUserIdStart = updateUserIdStart;
      public void setDeviceInFloorEnd(Integer deviceInFloorEnd){
      this.deviceInFloorEnd = deviceInFloorEnd;
      }
      /**
      * 获取 结束 更新用户
      * @return $updateUserIdEnd
      * 获取 增加 所属楼层
      * @return deviceInFloorIncrement
      */
      public Long getUpdateUserIdEnd(){
      return this.updateUserIdEnd;
      public Integer getDeviceInFloorIncrement(){
      return this.deviceInFloorIncrement;
      }
      /**
      * 设置 结束 更新用户
      * @param updateUserIdEnd
      * 设置 增加 所属楼层
      * @param deviceInFloorIncrement
      */
      public void setUpdateUserIdEnd(Long updateUserIdEnd){
      this.updateUserIdEnd = updateUserIdEnd;
      public void setDeviceInFloorIncrement(Integer deviceInFloorIncrement){
      this.deviceInFloorIncrement = deviceInFloorIncrement;
      }
      /**
      * 获取 增加 更新用户
      * @return updateUserIdIncrement
      * 获取 所属楼层
      * @return deviceInFloorList
      */
      public Long getUpdateUserIdIncrement(){
      return this.updateUserIdIncrement;
      public List<Integer> getDeviceInFloorList(){
      return this.deviceInFloorList;
      }
      /**
      * 设置 增加 更新用户
      * @param updateUserIdIncrement
      * 设置 所属楼层
      * @param deviceInFloorList
      */
      public void setUpdateUserIdIncrement(Long updateUserIdIncrement){
      this.updateUserIdIncrement = updateUserIdIncrement;
      public void setDeviceInFloorList(List<Integer> deviceInFloorList){
      this.deviceInFloorList = deviceInFloorList;
      }
      /**
      * 获取 更新用户
      * @return updateUserIdList
      * 获取 所属楼层
      * @return deviceInFloorNotList
      */
      public List<Long> getUpdateUserIdList(){
      return this.updateUserIdList;
      public List<Integer> getDeviceInFloorNotList(){
      return this.deviceInFloorNotList;
      }
      /**
      * 设置 更新用户
      * @param updateUserIdList
      * 设置 所属楼层
      * @param deviceInFloorNotList
      */
      public void setUpdateUserIdList(List<Long> updateUserIdList){
      this.updateUserIdList = updateUserIdList;
      public void setDeviceInFloorNotList(List<Integer> deviceInFloorNotList){
      this.deviceInFloorNotList = deviceInFloorNotList;
      }
      /**
      * 获取 更新用户
      * @return updateUserIdNotList
      */
      public List<Long> getUpdateUserIdNotList(){
      return this.updateUserIdNotList;
      }
      /**
      * 设置 更新用户
      * @param updateUserIdNotList
      * 获取 开始 最近上线时间
      * @return onlineTimeStart
      */
      public void setUpdateUserIdNotList(List<Long> updateUserIdNotList){
      this.updateUserIdNotList = updateUserIdNotList;
      public String getOnlineTimeStart(){
      return this.onlineTimeStart;
      }
      /**
      * 获取 开始 更新时间
      * @return updateTimeStart
      * 设置 开始 最近上线时间
      * @param onlineTimeStart
      */
      public String getUpdateTimeStart(){
      return this.updateTimeStart;
      public void setOnlineTimeStart(String onlineTimeStart){
      this.onlineTimeStart = onlineTimeStart;
      }
      /**
      * 设置 开始 更新时间
      * @param updateTimeStart
      * 获取 结束 最近上线时间
      * @return onlineTimeEnd
      */
      public void setUpdateTimeStart(String updateTimeStart){
      this.updateTimeStart = updateTimeStart;
      public String getOnlineTimeEnd(){
      return this.onlineTimeEnd;
      }
      /**
      * 获取 结束 更新时间
      * @return updateTimeEnd
      * 设置 结束 最近上线时间
      * @param onlineTimeEnd
      */
      public String getUpdateTimeEnd(){
      return this.updateTimeEnd;
      public void setOnlineTimeEnd(String onlineTimeEnd){
      this.onlineTimeEnd = onlineTimeEnd;
      }
      /**
      * 设置 结束 更新时间
      * @param updateTimeEnd
      * 获取 开始 最近离线时间
      * @return offlineTimeStart
      */
      public void setUpdateTimeEnd(String updateTimeEnd){
      this.updateTimeEnd = updateTimeEnd;
      public String getOfflineTimeStart(){
      return this.offlineTimeStart;
      }
      /**
      * 获取 开始 设备生产厂商ID
      * @return deviceFirmIdStart
      * 设置 开始 最近离线时间
      * @param offlineTimeStart
      */
      public Long getDeviceFirmIdStart(){
      return this.deviceFirmIdStart;
      public void setOfflineTimeStart(String offlineTimeStart){
      this.offlineTimeStart = offlineTimeStart;
      }
      /**
      * 设置 开始 设备生产厂商ID
      * @param deviceFirmIdStart
      * 获取 结束 最近离线时间
      * @return offlineTimeEnd
      */
      public void setDeviceFirmIdStart(Long deviceFirmIdStart){
      this.deviceFirmIdStart = deviceFirmIdStart;
      public String getOfflineTimeEnd(){
      return this.offlineTimeEnd;
      }
      /**
      * 获取 结束 设备生产厂商ID
      * @return $deviceFirmIdEnd
      * 设置 结束 最近离线时间
      * @param offlineTimeEnd
      */
      public Long getDeviceFirmIdEnd(){
      return this.deviceFirmIdEnd;
      public void setOfflineTimeEnd(String offlineTimeEnd){
      this.offlineTimeEnd = offlineTimeEnd;
      }
      /**
      * 设置 结束 设备生产厂商ID
      * @param deviceFirmIdEnd
      * 获取 开始 设备来源(0.旧设备，1.新设备)
      * @return sourceStart
      */
      public void setDeviceFirmIdEnd(Long deviceFirmIdEnd){
      this.deviceFirmIdEnd = deviceFirmIdEnd;
      public Integer getSourceStart(){
      return this.sourceStart;
      }
      /**
      * 获取 增加 设备生产厂商ID
      * @return deviceFirmIdIncrement
      * 设置 开始 设备来源(0.旧设备，1.新设备)
      * @param sourceStart
      */
      public Long getDeviceFirmIdIncrement(){
      return this.deviceFirmIdIncrement;
      public void setSourceStart(Integer sourceStart){
      this.sourceStart = sourceStart;
      }
      /**
      * 设置 增加 设备生产厂商ID
      * @param deviceFirmIdIncrement
      * 获取 结束 设备来源(0.旧设备，1.新设备)
      * @return $sourceEnd
      */
      public void setDeviceFirmIdIncrement(Long deviceFirmIdIncrement){
      this.deviceFirmIdIncrement = deviceFirmIdIncrement;
      public Integer getSourceEnd(){
      return this.sourceEnd;
      }
      /**
      * 获取 设备生产厂商ID
      * @return deviceFirmIdList
      * 设置 结束 设备来源(0.旧设备，1.新设备)
      * @param sourceEnd
      */
      public List<Long> getDeviceFirmIdList(){
      return this.deviceFirmIdList;
      public void setSourceEnd(Integer sourceEnd){
      this.sourceEnd = sourceEnd;
      }
      /**
      * 设置 设备生产厂商ID
      * @param deviceFirmIdList
      * 获取 增加 设备来源(0.旧设备，1.新设备)
      * @return sourceIncrement
      */
      public void setDeviceFirmIdList(List<Long> deviceFirmIdList){
      this.deviceFirmIdList = deviceFirmIdList;
      public Integer getSourceIncrement(){
      return this.sourceIncrement;
      }
      /**
      * 获取 设备生产厂商ID
      * @return deviceFirmIdNotList
      * 设置 增加 设备来源(0.旧设备，1.新设备)
      * @param sourceIncrement
      */
      public List<Long> getDeviceFirmIdNotList(){
      return this.deviceFirmIdNotList;
      public void setSourceIncrement(Integer sourceIncrement){
      this.sourceIncrement = sourceIncrement;
      }
      /**
      * 设置 设备生产厂商ID
      * @param deviceFirmIdNotList
      * 获取 设备来源(0.旧设备，1.新设备)
      * @return sourceList
      */
      public void setDeviceFirmIdNotList(List<Long> deviceFirmIdNotList){
      this.deviceFirmIdNotList = deviceFirmIdNotList;
      public List<Integer> getSourceList(){
      return this.sourceList;
      }
      /**
      * 设置 设备来源(0.旧设备，1.新设备)
      * @param sourceList
      */
      public void setSourceList(List<Integer> sourceList){
      this.sourceList = sourceList;
      }
      /**
      * 获取 设备生产厂商名称
      * @return deviceFirmnameList
      * 获取 设备来源(0.旧设备，1.新设备)
      * @return sourceNotList
      */
      public List<String> getDeviceFirmnameList(){
      return this.deviceFirmnameList;
      public List<Integer> getSourceNotList(){
      return this.sourceNotList;
      }
      /**
      * 设置 设备生产厂商名称
      * @param deviceFirmnameList
      * 设置 设备来源(0.旧设备，1.新设备)
      * @param sourceNotList
      */
      public void setDeviceFirmnameList(List<String> deviceFirmnameList){
      this.deviceFirmnameList = deviceFirmnameList;
      public void setSourceNotList(List<Integer> sourceNotList){
      this.sourceNotList = sourceNotList;
      }
      /**
      * 获取 设备生产厂商名称
      * @return deviceFirmnameNotList
      * 获取 开始 创建用户
      * @return createUserIdStart
      */
      public List<String> getDeviceFirmnameNotList(){
      return this.deviceFirmnameNotList;
      public Long getCreateUserIdStart(){
      return this.createUserIdStart;
      }
      /**
      * 设置 设备生产厂商名称
      * @param deviceFirmnameNotList
      * 设置 开始 创建用户
      * @param createUserIdStart
      */
      public void setDeviceFirmnameNotList(List<String> deviceFirmnameNotList){
      this.deviceFirmnameNotList = deviceFirmnameNotList;
      public void setCreateUserIdStart(Long createUserIdStart){
      this.createUserIdStart = createUserIdStart;
      }
      /**
      * 获取 设备访问ip
      * @return ipList
      * 获取 结束 创建用户
      * @return $createUserIdEnd
      */
      public List<String> getIpList(){
      return this.ipList;
      public Long getCreateUserIdEnd(){
      return this.createUserIdEnd;
      }
      /**
      * 设置 设备访问ip
      * @param ipList
      * 设置 结束 创建用户
      * @param createUserIdEnd
      */
      public void setIpList(List<String> ipList){
      this.ipList = ipList;
      public void setCreateUserIdEnd(Long createUserIdEnd){
      this.createUserIdEnd = createUserIdEnd;
      }
      /**
      * 获取 设备访问ip
      * @return ipNotList
      * 获取 增加 创建用户
      * @return createUserIdIncrement
      */
      public List<String> getIpNotList(){
      return this.ipNotList;
      public Long getCreateUserIdIncrement(){
      return this.createUserIdIncrement;
      }
      /**
      * 设置 设备访问ip
      * @param ipNotList
      * 设置 增加 创建用户
      * @param createUserIdIncrement
      */
      public void setIpNotList(List<String> ipNotList){
      this.ipNotList = ipNotList;
      public void setCreateUserIdIncrement(Long createUserIdIncrement){
      this.createUserIdIncrement = createUserIdIncrement;
      }
      /**
      * 获取 端口
      * @return portList
      * 获取 创建用户
      * @return createUserIdList
      */
      public List<String> getPortList(){
      return this.portList;
      public List<Long> getCreateUserIdList(){
      return this.createUserIdList;
      }
      /**
      * 设置 端口
      * @param portList
      * 设置 创建用户
      * @param createUserIdList
      */
      public void setPortList(List<String> portList){
      this.portList = portList;
      public void setCreateUserIdList(List<Long> createUserIdList){
      this.createUserIdList = createUserIdList;
      }
      /**
      * 获取 端口
      * @return portNotList
      * 获取 创建用户
      * @return createUserIdNotList
      */
      public List<String> getPortNotList(){
      return this.portNotList;
      public List<Long> getCreateUserIdNotList(){
      return this.createUserIdNotList;
      }
      /**
      * 设置 端口
      * @param portNotList
      * 设置 创建用户
      * @param createUserIdNotList
      */
      public void setPortNotList(List<String> portNotList){
      this.portNotList = portNotList;
      public void setCreateUserIdNotList(List<Long> createUserIdNotList){
      this.createUserIdNotList = createUserIdNotList;
      }
      /**
      * 获取 开始 启用状态 (0.停止，1.启用)
      * @return enabledStart
      * 获取 开始 创建时间
      * @return createTimeStart
      */
      public Integer getEnabledStart(){
      return this.enabledStart;
      public String getCreateTimeStart(){
      return this.createTimeStart;
      }
      /**
      * 设置 开始 启用状态 (0.停止，1.启用)
      * @param enabledStart
      * 设置 开始 创建时间
      * @param createTimeStart
      */
      public void setEnabledStart(Integer enabledStart){
      this.enabledStart = enabledStart;
      public void setCreateTimeStart(String createTimeStart){
      this.createTimeStart = createTimeStart;
      }
      /**
      * 获取 结束 启用状态 (0.停止，1.启用)
      * @return $enabledEnd
      * 获取 结束 创建时间
      * @return createTimeEnd
      */
      public Integer getEnabledEnd(){
      return this.enabledEnd;
      public String getCreateTimeEnd(){
      return this.createTimeEnd;
      }
      /**
      * 设置 结束 启用状态 (0.停止，1.启用)
      * @param enabledEnd
      * 设置 结束 创建时间
      * @param createTimeEnd
      */
      public void setEnabledEnd(Integer enabledEnd){
      this.enabledEnd = enabledEnd;
      public void setCreateTimeEnd(String createTimeEnd){
      this.createTimeEnd = createTimeEnd;
      }
      /**
      * 获取 增加 启用状态 (0.停止，1.启用)
      * @return enabledIncrement
      * 获取 开始 更新用户
      * @return updateUserIdStart
      */
      public Integer getEnabledIncrement(){
      return this.enabledIncrement;
      public Long getUpdateUserIdStart(){
      return this.updateUserIdStart;
      }
      /**
      * 设置 增加 启用状态 (0.停止，1.启用)
      * @param enabledIncrement
      * 设置 开始 更新用户
      * @param updateUserIdStart
      */
      public void setEnabledIncrement(Integer enabledIncrement){
      this.enabledIncrement = enabledIncrement;
      public void setUpdateUserIdStart(Long updateUserIdStart){
      this.updateUserIdStart = updateUserIdStart;
      }
      /**
      * 获取 启用状态 (0.停止，1.启用)
      * @return enabledList
      * 获取 结束 更新用户
      * @return $updateUserIdEnd
      */
      public List<Integer> getEnabledList(){
      return this.enabledList;
      public Long getUpdateUserIdEnd(){
      return this.updateUserIdEnd;
      }
      /**
      * 设置 启用状态 (0.停止，1.启用)
      * @param enabledList
      * 设置 结束 更新用户
      * @param updateUserIdEnd
      */
      public void setEnabledList(List<Integer> enabledList){
      this.enabledList = enabledList;
      public void setUpdateUserIdEnd(Long updateUserIdEnd){
      this.updateUserIdEnd = updateUserIdEnd;
      }
      /**
      * 获取 启用状态 (0.停止，1.启用)
      * @return enabledNotList
      * 获取 增加 更新用户
      * @return updateUserIdIncrement
      */
      public List<Integer> getEnabledNotList(){
      return this.enabledNotList;
      public Long getUpdateUserIdIncrement(){
      return this.updateUserIdIncrement;
      }
      /**
      * 设置 启用状态 (0.停止，1.启用)
      * @param enabledNotList
      * 设置 增加 更新用户
      * @param updateUserIdIncrement
      */
      public void setEnabledNotList(List<Integer> enabledNotList){
      this.enabledNotList = enabledNotList;
      public void setUpdateUserIdIncrement(Long updateUserIdIncrement){
      this.updateUserIdIncrement = updateUserIdIncrement;
      }
      /**
      * 获取 开始 最近上线时间
      * @return onlineTimeStart
      * 获取 更新用户
      * @return updateUserIdList
      */
      public String getOnlineTimeStart(){
      return this.onlineTimeStart;
      public List<Long> getUpdateUserIdList(){
      return this.updateUserIdList;
      }
      /**
      * 设置 开始 最近上线时间
      * @param onlineTimeStart
      * 设置 更新用户
      * @param updateUserIdList
      */
      public void setOnlineTimeStart(String onlineTimeStart){
      this.onlineTimeStart = onlineTimeStart;
      public void setUpdateUserIdList(List<Long> updateUserIdList){
      this.updateUserIdList = updateUserIdList;
      }
      /**
      * 获取 结束 最近上线时间
      * @return onlineTimeEnd
      * 获取 更新用户
      * @return updateUserIdNotList
      */
      public String getOnlineTimeEnd(){
      return this.onlineTimeEnd;
      public List<Long> getUpdateUserIdNotList(){
      return this.updateUserIdNotList;
      }
      /**
      * 设置 结束 最近上线时间
      * @param onlineTimeEnd
      * 设置 更新用户
      * @param updateUserIdNotList
      */
      public void setOnlineTimeEnd(String onlineTimeEnd){
      this.onlineTimeEnd = onlineTimeEnd;
      public void setUpdateUserIdNotList(List<Long> updateUserIdNotList){
      this.updateUserIdNotList = updateUserIdNotList;
      }
      /**
      * 获取 开始 最近离线时间
      * @return offlineTimeStart
      * 获取 开始 更新时间
      * @return updateTimeStart
      */
      public String getOfflineTimeStart(){
      return this.offlineTimeStart;
      public String getUpdateTimeStart(){
      return this.updateTimeStart;
      }
      /**
      * 设置 开始 最近离线时间
      * @param offlineTimeStart
      * 设置 开始 更新时间
      * @param updateTimeStart
      */
      public void setOfflineTimeStart(String offlineTimeStart){
      this.offlineTimeStart = offlineTimeStart;
      public void setUpdateTimeStart(String updateTimeStart){
      this.updateTimeStart = updateTimeStart;
      }
      /**
      * 获取 结束 最近离线时间
      * @return offlineTimeEnd
      * 获取 结束 更新时间
      * @return updateTimeEnd
      */
      public String getOfflineTimeEnd(){
      return this.offlineTimeEnd;
      public String getUpdateTimeEnd(){
      return this.updateTimeEnd;
      }
      /**
      * 设置 结束 最近离线时间
      * @param offlineTimeEnd
      * 设置 结束 更新时间
      * @param updateTimeEnd
      */
      public void setOfflineTimeEnd(String offlineTimeEnd){
      this.offlineTimeEnd = offlineTimeEnd;
      public void setUpdateTimeEnd(String updateTimeEnd){
      this.updateTimeEnd = updateTimeEnd;
      }
      /**
      ......@@ -1923,22 +2152,187 @@ public class DeviceQuery extends DeviceEntity {
      return this;
      }
      /**
      * 设置 站点名称
      * @param siteName
      */
      public DeviceQuery siteName(String siteName){
      setSiteName(siteName);
      return this;
      }
      /**
      * 设置 站点名称
      * @param siteNameList
      */
      public DeviceQuery siteNameList(List<String> siteNameList){
      this.siteNameList = siteNameList;
      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;
      }
      /**
      * 设置 站点名称
      * @param siteName
      * 设置 启用状态 (0.停止，1.启用)
      * @param enabledList
      */
      public DeviceQuery siteName(String siteName){
      setSiteName(siteName);
      public DeviceQuery enabledList(List<Integer> enabledList){
      this.enabledList = enabledList;
      return this;
      }
      /**
      * 设置 站点名称
      * @param siteNameList
      * 设置 启用状态 (0.停止，1.启用)
      * @param enabledNotList
      */
      public DeviceQuery siteNameList(List<String> siteNameList){
      this.siteNameList = siteNameList;
      public DeviceQuery enabledNotList(List<Integer> enabledNotList){
      this.enabledNotList = enabledNotList;
      return this;
      }
      ......@@ -2183,337 +2577,299 @@ public class DeviceQuery extends DeviceEntity {
      return this;
      }
      /**
      * 设置 设备来源(0.旧设备，1.新设备)
      * @param source
      */
      public DeviceQuery source(Integer source){
      setSource(source);
      return this;
      }
      /**
      * 设置 开始 设备来源(0.旧设备，1.新设备)
      * @param sourceStart
      * 设置 所属机构
      * @param belong
      */
      public DeviceQuery sourceStart(Integer sourceStart){
      this.sourceStart = sourceStart;
      public DeviceQuery belong(String belong){
      setBelong(belong);
      return this;
      }
      /**
      * 设置 结束 设备来源(0.旧设备，1.新设备)
      * @param sourceEnd
      * 设置 所属机构
      * @param belongList
      */
      public DeviceQuery sourceEnd(Integer sourceEnd){
      this.sourceEnd = sourceEnd;
      public DeviceQuery belongList(List<String> belongList){
      this.belongList = belongList;
      return this;
      }
      /**
      * 设置 增加 设备来源(0.旧设备，1.新设备)
      * @param sourceIncrement
      * 设置 所属楼栋
      * @param deviceInBuilding
      */
      public DeviceQuery sourceIncrement(Integer sourceIncrement){
      this.sourceIncrement = sourceIncrement;
      public DeviceQuery deviceInBuilding(Integer deviceInBuilding){
      setDeviceInBuilding(deviceInBuilding);
      return this;
      }
      /**
      * 设置 设备来源(0.旧设备，1.新设备)
      * @param sourceList
      * 设置 开始 所属楼栋
      * @param deviceInBuildingStart
      */
      public DeviceQuery sourceList(List<Integer> sourceList){
      this.sourceList = sourceList;
      public DeviceQuery deviceInBuildingStart(Integer deviceInBuildingStart){
      this.deviceInBuildingStart = deviceInBuildingStart;
      return this;
      }
      /**
      * 设置 设备来源(0.旧设备，1.新设备)
      * @param sourceNotList
      * 设置 结束 所属楼栋
      * @param deviceInBuildingEnd
      */
      public DeviceQuery sourceNotList(List<Integer> sourceNotList){
      this.sourceNotList = sourceNotList;
      public DeviceQuery deviceInBuildingEnd(Integer deviceInBuildingEnd){
      this.deviceInBuildingEnd = deviceInBuildingEnd;
      return this;
      }
      /**
      * 设置 创建用户
      * @param createUserId
      * 设置 增加 所属楼栋
      * @param deviceInBuildingIncrement
      */
      public DeviceQuery createUserId(Long createUserId){
      setCreateUserId(createUserId);
      public DeviceQuery deviceInBuildingIncrement(Integer deviceInBuildingIncrement){
      this.deviceInBuildingIncrement = deviceInBuildingIncrement;
      return this;
      }
      /**
      * 设置 开始 创建用户
      * @param createUserIdStart
      * 设置 所属楼栋
      * @param deviceInBuildingList
      */
      public DeviceQuery createUserIdStart(Long createUserIdStart){
      this.createUserIdStart = createUserIdStart;
      public DeviceQuery deviceInBuildingList(List<Integer> deviceInBuildingList){
      this.deviceInBuildingList = deviceInBuildingList;
      return this;
      }
      /**
      * 设置 结束 创建用户
      * @param createUserIdEnd
      * 设置 所属楼栋
      * @param deviceInBuildingNotList
      */
      public DeviceQuery createUserIdEnd(Long createUserIdEnd){
      this.createUserIdEnd = createUserIdEnd;
      public DeviceQuery deviceInBuildingNotList(List<Integer> deviceInBuildingNotList){
      this.deviceInBuildingNotList = deviceInBuildingNotList;
      return this;
      }
      /**
      * 设置 增加 创建用户
      * @param createUserIdIncrement
      * 设置 所属楼层
      * @param deviceInFloor
      */
      public DeviceQuery createUserIdIncrement(Long createUserIdIncrement){
      this.createUserIdIncrement = createUserIdIncrement;
      public DeviceQuery deviceInFloor(Integer deviceInFloor){
      setDeviceInFloor(deviceInFloor);
      return this;
      }
      /**
      * 设置 创建用户
      * @param createUserIdList
      * 设置 开始 所属楼层
      * @param deviceInFloorStart
      */
      public DeviceQuery createUserIdList(List<Long> createUserIdList){
      this.createUserIdList = createUserIdList;
      public DeviceQuery deviceInFloorStart(Integer deviceInFloorStart){
      this.deviceInFloorStart = deviceInFloorStart;
      return this;
      }
      /**
      * 设置 创建用户
      * @param createUserIdNotList
      * 设置 结束 所属楼层
      * @param deviceInFloorEnd
      */
      public DeviceQuery createUserIdNotList(List<Long> createUserIdNotList){
      this.createUserIdNotList = createUserIdNotList;
      public DeviceQuery deviceInFloorEnd(Integer deviceInFloorEnd){
      this.deviceInFloorEnd = deviceInFloorEnd;
      return this;
      }
      /**
      * 设置 更新用户
      * @param updateUserId
      * 设置 增加 所属楼层
      * @param deviceInFloorIncrement
      */
      public DeviceQuery updateUserId(Long updateUserId){
      setUpdateUserId(updateUserId);
      public DeviceQuery deviceInFloorIncrement(Integer deviceInFloorIncrement){
      this.deviceInFloorIncrement = deviceInFloorIncrement;
      return this;
      }
      /**
      * 设置 开始 更新用户
      * @param updateUserIdStart
      * 设置 所属楼层
      * @param deviceInFloorList
      */
      public DeviceQuery updateUserIdStart(Long updateUserIdStart){
      this.updateUserIdStart = updateUserIdStart;
      public DeviceQuery deviceInFloorList(List<Integer> deviceInFloorList){
      this.deviceInFloorList = deviceInFloorList;
      return this;
      }
      /**
      * 设置 结束 更新用户
      * @param updateUserIdEnd
      * 设置 所属楼层
      * @param deviceInFloorNotList
      */
      public DeviceQuery updateUserIdEnd(Long updateUserIdEnd){
      this.updateUserIdEnd = updateUserIdEnd;
      public DeviceQuery deviceInFloorNotList(List<Integer> deviceInFloorNotList){
      this.deviceInFloorNotList = deviceInFloorNotList;
      return this;
      }
      /**
      * 设置 增加 更新用户
      * @param updateUserIdIncrement
      */
      public DeviceQuery updateUserIdIncrement(Long updateUserIdIncrement){
      this.updateUserIdIncrement = updateUserIdIncrement;
      return this;
      }
      /**
      * 设置 更新用户
      * @param updateUserIdList
      */
      public DeviceQuery updateUserIdList(List<Long> updateUserIdList){
      this.updateUserIdList = updateUserIdList;
      return this;
      }
      /**
      * 设置 更新用户
      * @param updateUserIdNotList
      * 设置 设备来源(0.旧设备，1.新设备)
      * @param source
      */
      public DeviceQuery updateUserIdNotList(List<Long> updateUserIdNotList){
      this.updateUserIdNotList = updateUserIdNotList;
      public DeviceQuery source(Integer source){
      setSource(source);
      return this;
      }
      /**
      * 设置 设备生产厂商ID
      * @param deviceFirmId
      * 设置 开始 设备来源(0.旧设备，1.新设备)
      * @param sourceStart
      */
      public DeviceQuery deviceFirmId(Long deviceFirmId){
      setDeviceFirmId(deviceFirmId);
      public DeviceQuery sourceStart(Integer sourceStart){
      this.sourceStart = sourceStart;
      return this;
      }
      /**
      * 设置 开始 设备生产厂商ID
      * @param deviceFirmIdStart
      * 设置 结束 设备来源(0.旧设备，1.新设备)
      * @param sourceEnd
      */
      public DeviceQuery deviceFirmIdStart(Long deviceFirmIdStart){
      this.deviceFirmIdStart = deviceFirmIdStart;
      public DeviceQuery sourceEnd(Integer sourceEnd){
      this.sourceEnd = sourceEnd;
      return this;
      }
      /**
      * 设置 结束 设备生产厂商ID
      * @param deviceFirmIdEnd
      * 设置 增加 设备来源(0.旧设备，1.新设备)
      * @param sourceIncrement
      */
      public DeviceQuery deviceFirmIdEnd(Long deviceFirmIdEnd){
      this.deviceFirmIdEnd = deviceFirmIdEnd;
      public DeviceQuery sourceIncrement(Integer sourceIncrement){
      this.sourceIncrement = sourceIncrement;
      return this;
      }
      /**
      * 设置 增加 设备生产厂商ID
      * @param deviceFirmIdIncrement
      * 设置 设备来源(0.旧设备，1.新设备)
      * @param sourceList
      */
      public DeviceQuery deviceFirmIdIncrement(Long deviceFirmIdIncrement){
      this.deviceFirmIdIncrement = deviceFirmIdIncrement;
      public DeviceQuery sourceList(List<Integer> sourceList){
      this.sourceList = sourceList;
      return this;
      }
      /**
      * 设置 设备生产厂商ID
      * @param deviceFirmIdList
      * 设置 设备来源(0.旧设备，1.新设备)
      * @param sourceNotList
      */
      public DeviceQuery deviceFirmIdList(List<Long> deviceFirmIdList){
      this.deviceFirmIdList = deviceFirmIdList;
      public DeviceQuery sourceNotList(List<Integer> sourceNotList){
      this.sourceNotList = sourceNotList;
      return this;
      }
      /**
      * 设置 设备生产厂商ID
      * @param deviceFirmIdNotList
      * 设置 创建用户
      * @param createUserId
      */
      public DeviceQuery deviceFirmIdNotList(List<Long> deviceFirmIdNotList){
      this.deviceFirmIdNotList = deviceFirmIdNotList;
      public DeviceQuery createUserId(Long createUserId){
      setCreateUserId(createUserId);
      return this;
      }
      /**
      * 设置 设备生产厂商名称
      * @param deviceFirmname
      * 设置 开始 创建用户
      * @param createUserIdStart
      */
      public DeviceQuery deviceFirmname(String deviceFirmname){
      setDeviceFirmname(deviceFirmname);
      public DeviceQuery createUserIdStart(Long createUserIdStart){
      this.createUserIdStart = createUserIdStart;
      return this;
      }
      /**
      * 设置 设备生产厂商名称
      * @param deviceFirmnameList
      * 设置 结束 创建用户
      * @param createUserIdEnd
      */
      public DeviceQuery deviceFirmnameList(List<String> deviceFirmnameList){
      this.deviceFirmnameList = deviceFirmnameList;
      public DeviceQuery createUserIdEnd(Long createUserIdEnd){
      this.createUserIdEnd = createUserIdEnd;
      return this;
      }
      /**
      * 设置 设备访问ip
      * @param ip
      * 设置 增加 创建用户
      * @param createUserIdIncrement
      */
      public DeviceQuery ip(String ip){
      setIp(ip);
      public DeviceQuery createUserIdIncrement(Long createUserIdIncrement){
      this.createUserIdIncrement = createUserIdIncrement;
      return this;
      }
      /**
      * 设置 设备访问ip
      * @param ipList
      * 设置 创建用户
      * @param createUserIdList
      */
      public DeviceQuery ipList(List<String> ipList){
      this.ipList = ipList;
      public DeviceQuery createUserIdList(List<Long> createUserIdList){
      this.createUserIdList = createUserIdList;
      return this;
      }
      /**
      * 设置 端口
      * @param port
      * 设置 创建用户
      * @param createUserIdNotList
      */
      public DeviceQuery port(String port){
      setPort(port);
      public DeviceQuery createUserIdNotList(List<Long> createUserIdNotList){
      this.createUserIdNotList = createUserIdNotList;
      return this;
      }
      /**
      * 设置 端口
      * @param portList
      */
      public DeviceQuery portList(List<String> portList){
      this.portList = portList;
      return this;
      }
      /**
      * 设置 启用状态 (0.停止，1.启用)
      * @param enabled
      * 设置 更新用户
      * @param updateUserId
      */
      public DeviceQuery enabled(Integer enabled){
      setEnabled(enabled);
      public DeviceQuery updateUserId(Long updateUserId){
      setUpdateUserId(updateUserId);
      return this;
      }
      /**
      * 设置 开始 启用状态 (0.停止，1.启用)
      * @param enabledStart
      * 设置 开始 更新用户
      * @param updateUserIdStart
      */
      public DeviceQuery enabledStart(Integer enabledStart){
      this.enabledStart = enabledStart;
      public DeviceQuery updateUserIdStart(Long updateUserIdStart){
      this.updateUserIdStart = updateUserIdStart;
      return this;
      }
      /**
      * 设置 结束 启用状态 (0.停止，1.启用)
      * @param enabledEnd
      * 设置 结束 更新用户
      * @param updateUserIdEnd
      */
      public DeviceQuery enabledEnd(Integer enabledEnd){
      this.enabledEnd = enabledEnd;
      public DeviceQuery updateUserIdEnd(Long updateUserIdEnd){
      this.updateUserIdEnd = updateUserIdEnd;
      return this;
      }
      /**
      * 设置 增加 启用状态 (0.停止，1.启用)
      * @param enabledIncrement
      * 设置 增加 更新用户
      * @param updateUserIdIncrement
      */
      public DeviceQuery enabledIncrement(Integer enabledIncrement){
      this.enabledIncrement = enabledIncrement;
      public DeviceQuery updateUserIdIncrement(Long updateUserIdIncrement){
      this.updateUserIdIncrement = updateUserIdIncrement;
      return this;
      }
      /**
      * 设置 启用状态 (0.停止，1.启用)
      * @param enabledList
      * 设置 更新用户
      * @param updateUserIdList
      */
      public DeviceQuery enabledList(List<Integer> enabledList){
      this.enabledList = enabledList;
      public DeviceQuery updateUserIdList(List<Long> updateUserIdList){
      this.updateUserIdList = updateUserIdList;
      return this;
      }
      /**
      * 设置 启用状态 (0.停止，1.启用)
      * @param enabledNotList
      * 设置 更新用户
      * @param updateUserIdNotList
      */
      public DeviceQuery enabledNotList(List<Integer> enabledNotList){
      this.enabledNotList = enabledNotList;
      public DeviceQuery updateUserIdNotList(List<Long> updateUserIdNotList){
      this.updateUserIdNotList = updateUserIdNotList;
      return this;
      }
      /**
      * 获取 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
      * @return orConditionList
      ......
      fill-manager/src/main/resources/sqlmap/module/device/DeviceMapper.xml
      View file @ 090cf87b
      ......@@ -13,6 +13,11 @@
      <result property="siteId" column="siteId" />
      <result property="siteCode" column="siteCode" />
      <result property="siteName" column="siteName" />
      <result property="deviceFirmId" column="deviceFirmId" />
      <result property="deviceFirmname" column="deviceFirmname" />
      <result property="ip" column="ip" />
      <result property="port" column="port" />
      <result property="enabled" column="enabled" />
      <result property="productCode" column="productCode" />
      <result property="productName" column="productName" />
      <result property="deviceSrc" column="deviceSrc" />
      ......@@ -22,18 +27,16 @@
      <result property="leadingOfficialTelephone" column="leadingOfficialTelephone" />
      <result property="deviceStatus" column="deviceStatus" />
      <result property="deviceRemark" column="deviceRemark" />
      <result property="belong" column="belong" />
      <result property="deviceInBuilding" column="deviceInBuilding" />
      <result property="deviceInFloor" column="deviceInFloor" />
      <result property="onlineTime" column="onlineTime" />
      <result property="offlineTime" column="offlineTime" />
      <result property="source" column="source" />
      <result property="createUserId" column="createUserId" />
      <result property="createTime" column="createTime" />
      <result property="updateUserId" column="updateUserId" />
      <result property="updateTime" column="updateTime" />
      <result property="deviceFirmId" column="deviceFirmId" />
      <result property="deviceFirmname" column="deviceFirmname" />
      <result property="ip" column="ip" />
      <result property="port" column="port" />
      <result property="enabled" column="enabled" />
      <result property="onlineTime" column="onlineTime" />
      <result property="offlineTime" column="offlineTime" />
      </resultMap>
      ......@@ -65,6 +68,21 @@
      <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('siteName') or colPickMode == 1 and data.containsKey('siteName')))">
      a.siteName,
      </if>
      <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('deviceFirmId') or colPickMode == 1 and data.containsKey('deviceFirmId')))">
      a.deviceFirmId,
      </if>
      <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('deviceFirmname') or colPickMode == 1 and data.containsKey('deviceFirmname')))">
      a.deviceFirmname,
      </if>
      <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('ip') or colPickMode == 1 and data.containsKey('ip')))">
      a.ip,
      </if>
      <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('port') or colPickMode == 1 and data.containsKey('port')))">
      a.port,
      </if>
      <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('enabled') or colPickMode == 1 and data.containsKey('enabled')))">
      a.enabled,
      </if>
      <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('productCode') or colPickMode == 1 and data.containsKey('productCode')))">
      a.productCode,
      </if>
      ......@@ -92,6 +110,21 @@
      <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('deviceRemark') or colPickMode == 1 and data.containsKey('deviceRemark')))">
      a.deviceRemark,
      </if>
      <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('belong') or colPickMode == 1 and data.containsKey('belong')))">
      a.belong,
      </if>
      <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('deviceInBuilding') or colPickMode == 1 and data.containsKey('deviceInBuilding')))">
      a.deviceInBuilding,
      </if>
      <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('deviceInFloor') or colPickMode == 1 and data.containsKey('deviceInFloor')))">
      a.deviceInFloor,
      </if>
      <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('onlineTime') or colPickMode == 1 and data.containsKey('onlineTime')))">
      a.onlineTime,
      </if>
      <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('offlineTime') or colPickMode == 1 and data.containsKey('offlineTime')))">
      a.offlineTime,
      </if>
      <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('source') or colPickMode == 1 and data.containsKey('source')))">
      a.source,
      </if>
      ......@@ -107,44 +140,23 @@
      <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateTime') or colPickMode == 1 and data.containsKey('updateTime')))">
      a.updateTime,
      </if>
      <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('deviceFirmId') or colPickMode == 1 and data.containsKey('deviceFirmId')))">
      a.deviceFirmId,
      </if>
      <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('deviceFirmname') or colPickMode == 1 and data.containsKey('deviceFirmname')))">
      a.deviceFirmname,
      </if>
      <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('ip') or colPickMode == 1 and data.containsKey('ip')))">
      a.ip,
      </if>
      <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('port') or colPickMode == 1 and data.containsKey('port')))">
      a.port,
      </if>
      <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('enabled') or colPickMode == 1 and data.containsKey('enabled')))">
      a.enabled,
      </if>
      <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('onlineTime') or colPickMode == 1 and data.containsKey('onlineTime')))">
      a.onlineTime,
      </if>
      <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('offlineTime') or colPickMode == 1 and data.containsKey('offlineTime')))">
      a.offlineTime,
      </if>
      </trim>
      </sql>
      <!-- 新增 区分主键自增加还是业务插入 -->
      <insert id="insert" parameterType="DeviceEntity" useGeneratedKeys="true" keyProperty="id">
      insert into mortals_xhx_device
      (deviceId,deviceName,deviceCode,deviceMac,siteId,siteCode,siteName,productCode,productName,deviceSrc,lon,lati,leadingOfficial,leadingOfficialTelephone,deviceStatus,deviceRemark,source,createUserId,createTime,updateUserId,updateTime,deviceFirmId,deviceFirmname,ip,port,enabled,onlineTime,offlineTime)
      (deviceId,deviceName,deviceCode,deviceMac,siteId,siteCode,siteName,deviceFirmId,deviceFirmname,ip,port,enabled,productCode,productName,deviceSrc,lon,lati,leadingOfficial,leadingOfficialTelephone,deviceStatus,deviceRemark,belong,deviceInBuilding,deviceInFloor,onlineTime,offlineTime,source,createUserId,createTime,updateUserId,updateTime)
      VALUES
      (#{deviceId},#{deviceName},#{deviceCode},#{deviceMac},#{siteId},#{siteCode},#{siteName},#{productCode},#{productName},#{deviceSrc},#{lon},#{lati},#{leadingOfficial},#{leadingOfficialTelephone},#{deviceStatus},#{deviceRemark},#{source},#{createUserId},#{createTime},#{updateUserId},#{updateTime},#{deviceFirmId},#{deviceFirmname},#{ip},#{port},#{enabled},#{onlineTime},#{offlineTime})
      (#{deviceId},#{deviceName},#{deviceCode},#{deviceMac},#{siteId},#{siteCode},#{siteName},#{deviceFirmId},#{deviceFirmname},#{ip},#{port},#{enabled},#{productCode},#{productName},#{deviceSrc},#{lon},#{lati},#{leadingOfficial},#{leadingOfficialTelephone},#{deviceStatus},#{deviceRemark},#{belong},#{deviceInBuilding},#{deviceInFloor},#{onlineTime},#{offlineTime},#{source},#{createUserId},#{createTime},#{updateUserId},#{updateTime})
      </insert>
      <!-- 批量新增 -->
      <insert id="insertBatch" parameterType="paramDto">
      insert into mortals_xhx_device
      (deviceId,deviceName,deviceCode,deviceMac,siteId,siteCode,siteName,productCode,productName,deviceSrc,lon,lati,leadingOfficial,leadingOfficialTelephone,deviceStatus,deviceRemark,source,createUserId,createTime,updateUserId,updateTime,deviceFirmId,deviceFirmname,ip,port,enabled,onlineTime,offlineTime)
      (deviceId,deviceName,deviceCode,deviceMac,siteId,siteCode,siteName,deviceFirmId,deviceFirmname,ip,port,enabled,productCode,productName,deviceSrc,lon,lati,leadingOfficial,leadingOfficialTelephone,deviceStatus,deviceRemark,belong,deviceInBuilding,deviceInFloor,onlineTime,offlineTime,source,createUserId,createTime,updateUserId,updateTime)
      VALUES
      <foreach collection="data.dataList" item="item" index="index" separator="," >
      (#{item.deviceId},#{item.deviceName},#{item.deviceCode},#{item.deviceMac},#{item.siteId},#{item.siteCode},#{item.siteName},#{item.productCode},#{item.productName},#{item.deviceSrc},#{item.lon},#{item.lati},#{item.leadingOfficial},#{item.leadingOfficialTelephone},#{item.deviceStatus},#{item.deviceRemark},#{item.source},#{item.createUserId},#{item.createTime},#{item.updateUserId},#{item.updateTime},#{item.deviceFirmId},#{item.deviceFirmname},#{item.ip},#{item.port},#{item.enabled},#{item.onlineTime},#{item.offlineTime})
      (#{item.deviceId},#{item.deviceName},#{item.deviceCode},#{item.deviceMac},#{item.siteId},#{item.siteCode},#{item.siteName},#{item.deviceFirmId},#{item.deviceFirmname},#{item.ip},#{item.port},#{item.enabled},#{item.productCode},#{item.productName},#{item.deviceSrc},#{item.lon},#{item.lati},#{item.leadingOfficial},#{item.leadingOfficialTelephone},#{item.deviceStatus},#{item.deviceRemark},#{item.belong},#{item.deviceInBuilding},#{item.deviceInFloor},#{item.onlineTime},#{item.offlineTime},#{item.source},#{item.createUserId},#{item.createTime},#{item.updateUserId},#{item.updateTime})
      </foreach>
      </insert>
      ......@@ -181,6 +193,27 @@
      <if test="(colPickMode==0 and data.containsKey('siteName')) or (colPickMode==1 and !data.containsKey('siteName'))">
      a.siteName=#{data.siteName},
      </if>
      <if test="(colPickMode==0 and data.containsKey('deviceFirmId')) or (colPickMode==1 and !data.containsKey('deviceFirmId'))">
      a.deviceFirmId=#{data.deviceFirmId},
      </if>
      <if test="(colPickMode==0 and data.containsKey('deviceFirmIdIncrement')) or (colPickMode==1 and !data.containsKey('deviceFirmIdIncrement'))">
      a.deviceFirmId=ifnull(a.deviceFirmId,0) + #{data.deviceFirmIdIncrement},
      </if>
      <if test="(colPickMode==0 and data.containsKey('deviceFirmname')) or (colPickMode==1 and !data.containsKey('deviceFirmname'))">
      a.deviceFirmname=#{data.deviceFirmname},
      </if>
      <if test="(colPickMode==0 and data.containsKey('ip')) or (colPickMode==1 and !data.containsKey('ip'))">
      a.ip=#{data.ip},
      </if>
      <if test="(colPickMode==0 and data.containsKey('port')) or (colPickMode==1 and !data.containsKey('port'))">
      a.port=#{data.port},
      </if>
      <if test="(colPickMode==0 and data.containsKey('enabled')) or (colPickMode==1 and !data.containsKey('enabled'))">
      a.enabled=#{data.enabled},
      </if>
      <if test="(colPickMode==0 and data.containsKey('enabledIncrement')) or (colPickMode==1 and !data.containsKey('enabledIncrement'))">
      a.enabled=ifnull(a.enabled,0) + #{data.enabledIncrement},
      </if>
      <if test="(colPickMode==0 and data.containsKey('productCode')) or (colPickMode==1 and !data.containsKey('productCode'))">
      a.productCode=#{data.productCode},
      </if>
      ......@@ -214,6 +247,27 @@
      <if test="(colPickMode==0 and data.containsKey('deviceRemark')) or (colPickMode==1 and !data.containsKey('deviceRemark'))">
      a.deviceRemark=#{data.deviceRemark},
      </if>
      <if test="(colPickMode==0 and data.containsKey('belong')) or (colPickMode==1 and !data.containsKey('belong'))">
      a.belong=#{data.belong},
      </if>
      <if test="(colPickMode==0 and data.containsKey('deviceInBuilding')) or (colPickMode==1 and !data.containsKey('deviceInBuilding'))">
      a.deviceInBuilding=#{data.deviceInBuilding},
      </if>
      <if test="(colPickMode==0 and data.containsKey('deviceInBuildingIncrement')) or (colPickMode==1 and !data.containsKey('deviceInBuildingIncrement'))">
      a.deviceInBuilding=ifnull(a.deviceInBuilding,0) + #{data.deviceInBuildingIncrement},
      </if>
      <if test="(colPickMode==0 and data.containsKey('deviceInFloor')) or (colPickMode==1 and !data.containsKey('deviceInFloor'))">
      a.deviceInFloor=#{data.deviceInFloor},
      </if>
      <if test="(colPickMode==0 and data.containsKey('deviceInFloorIncrement')) or (colPickMode==1 and !data.containsKey('deviceInFloorIncrement'))">
      a.deviceInFloor=ifnull(a.deviceInFloor,0) + #{data.deviceInFloorIncrement},
      </if>
      <if test="(colPickMode==0 and data.containsKey('onlineTime')) or (colPickMode==1 and !data.containsKey('onlineTime'))">
      a.onlineTime=#{data.onlineTime},
      </if>
      <if test="(colPickMode==0 and data.containsKey('offlineTime')) or (colPickMode==1 and !data.containsKey('offlineTime'))">
      a.offlineTime=#{data.offlineTime},
      </if>
      <if test="(colPickMode==0 and data.containsKey('source')) or (colPickMode==1 and !data.containsKey('source'))">
      a.source=#{data.source},
      </if>
      ......@@ -238,33 +292,6 @@
      <if test="(colPickMode==0 and data.containsKey('updateTime')) or (colPickMode==1 and !data.containsKey('updateTime'))">
      a.updateTime=#{data.updateTime},
      </if>
      <if test="(colPickMode==0 and data.containsKey('deviceFirmId')) or (colPickMode==1 and !data.containsKey('deviceFirmId'))">
      a.deviceFirmId=#{data.deviceFirmId},
      </if>
      <if test="(colPickMode==0 and data.containsKey('deviceFirmIdIncrement')) or (colPickMode==1 and !data.containsKey('deviceFirmIdIncrement'))">
      a.deviceFirmId=ifnull(a.deviceFirmId,0) + #{data.deviceFirmIdIncrement},
      </if>
      <if test="(colPickMode==0 and data.containsKey('deviceFirmname')) or (colPickMode==1 and !data.containsKey('deviceFirmname'))">
      a.deviceFirmname=#{data.deviceFirmname},
      </if>
      <if test="(colPickMode==0 and data.containsKey('ip')) or (colPickMode==1 and !data.containsKey('ip'))">
      a.ip=#{data.ip},
      </if>
      <if test="(colPickMode==0 and data.containsKey('port')) or (colPickMode==1 and !data.containsKey('port'))">
      a.port=#{data.port},
      </if>
      <if test="(colPickMode==0 and data.containsKey('enabled')) or (colPickMode==1 and !data.containsKey('enabled'))">
      a.enabled=#{data.enabled},
      </if>
      <if test="(colPickMode==0 and data.containsKey('enabledIncrement')) or (colPickMode==1 and !data.containsKey('enabledIncrement'))">
      a.enabled=ifnull(a.enabled,0) + #{data.enabledIncrement},
      </if>
      <if test="(colPickMode==0 and data.containsKey('onlineTime')) or (colPickMode==1 and !data.containsKey('onlineTime'))">
      a.onlineTime=#{data.onlineTime},
      </if>
      <if test="(colPickMode==0 and data.containsKey('offlineTime')) or (colPickMode==1 and !data.containsKey('offlineTime'))">
      a.offlineTime=#{data.offlineTime},
      </if>
      </trim>
      <trim suffixOverrides="where" suffix="">
      where
      ......@@ -336,6 +363,51 @@
      </if>
      </foreach>
      </trim>
      <trim prefix="deviceFirmId=(case" suffix="ELSE deviceFirmId end),">
      <foreach collection="data.dataList" item="item" index="index" separator="" >
      <choose>
      <when test="(colPickMode==0 and item.containsKey('deviceFirmId')) or (colPickMode==1 and !item.containsKey('deviceFirmId'))">
      when a.id=#{item.id} then #{item.deviceFirmId}
      </when>
      <when test="(colPickMode==0 and item.containsKey('deviceFirmIdIncrement')) or (colPickMode==1 and !item.containsKey('deviceFirmIdIncrement'))">
      when a.id=#{item.id} then ifnull(a.deviceFirmId,0) + #{item.deviceFirmIdIncrement}
      </when>
      </choose>
      </foreach>
      </trim>
      <trim prefix="deviceFirmname=(case" suffix="ELSE deviceFirmname end),">
      <foreach collection="data.dataList" item="item" index="index" separator="" >
      <if test="(colPickMode==0 and item.containsKey('deviceFirmname')) or (colPickMode==1 and !item.containsKey('deviceFirmname'))">
      when a.id=#{item.id} then #{item.deviceFirmname}
      </if>
      </foreach>
      </trim>
      <trim prefix="ip=(case" suffix="ELSE ip end),">
      <foreach collection="data.dataList" item="item" index="index" separator="" >
      <if test="(colPickMode==0 and item.containsKey('ip')) or (colPickMode==1 and !item.containsKey('ip'))">
      when a.id=#{item.id} then #{item.ip}
      </if>
      </foreach>
      </trim>
      <trim prefix="port=(case" suffix="ELSE port end),">
      <foreach collection="data.dataList" item="item" index="index" separator="" >
      <if test="(colPickMode==0 and item.containsKey('port')) or (colPickMode==1 and !item.containsKey('port'))">
      when a.id=#{item.id} then #{item.port}
      </if>
      </foreach>
      </trim>
      <trim prefix="enabled=(case" suffix="ELSE enabled end),">
      <foreach collection="data.dataList" item="item" index="index" separator="" >
      <choose>
      <when test="(colPickMode==0 and item.containsKey('enabled')) or (colPickMode==1 and !item.containsKey('enabled'))">
      when a.id=#{item.id} then #{item.enabled}
      </when>
      <when test="(colPickMode==0 and item.containsKey('enabledIncrement')) or (colPickMode==1 and !item.containsKey('enabledIncrement'))">
      when a.id=#{item.id} then ifnull(a.enabled,0) + #{item.enabledIncrement}
      </when>
      </choose>
      </foreach>
      </trim>
      <trim prefix="productCode=(case" suffix="ELSE productCode end),">
      <foreach collection="data.dataList" item="item" index="index" separator="" >
      <if test="(colPickMode==0 and item.containsKey('productCode')) or (colPickMode==1 and !item.containsKey('productCode'))">
      ......@@ -409,6 +481,51 @@
      </if>
      </foreach>
      </trim>
      <trim prefix="belong=(case" suffix="ELSE belong end),">
      <foreach collection="data.dataList" item="item" index="index" separator="" >
      <if test="(colPickMode==0 and item.containsKey('belong')) or (colPickMode==1 and !item.containsKey('belong'))">
      when a.id=#{item.id} then #{item.belong}
      </if>
      </foreach>
      </trim>
      <trim prefix="deviceInBuilding=(case" suffix="ELSE deviceInBuilding end),">
      <foreach collection="data.dataList" item="item" index="index" separator="" >
      <choose>
      <when test="(colPickMode==0 and item.containsKey('deviceInBuilding')) or (colPickMode==1 and !item.containsKey('deviceInBuilding'))">
      when a.id=#{item.id} then #{item.deviceInBuilding}
      </when>
      <when test="(colPickMode==0 and item.containsKey('deviceInBuildingIncrement')) or (colPickMode==1 and !item.containsKey('deviceInBuildingIncrement'))">
      when a.id=#{item.id} then ifnull(a.deviceInBuilding,0) + #{item.deviceInBuildingIncrement}
      </when>
      </choose>
      </foreach>
      </trim>
      <trim prefix="deviceInFloor=(case" suffix="ELSE deviceInFloor end),">
      <foreach collection="data.dataList" item="item" index="index" separator="" >
      <choose>
      <when test="(colPickMode==0 and item.containsKey('deviceInFloor')) or (colPickMode==1 and !item.containsKey('deviceInFloor'))">
      when a.id=#{item.id} then #{item.deviceInFloor}
      </when>
      <when test="(colPickMode==0 and item.containsKey('deviceInFloorIncrement')) or (colPickMode==1 and !item.containsKey('deviceInFloorIncrement'))">
      when a.id=#{item.id} then ifnull(a.deviceInFloor,0) + #{item.deviceInFloorIncrement}
      </when>
      </choose>
      </foreach>
      </trim>
      <trim prefix="onlineTime=(case" suffix="ELSE onlineTime end),">
      <foreach collection="data.dataList" item="item" index="index" separator="" >
      <if test="(colPickMode==0 and item.containsKey('onlineTime')) or (colPickMode==1 and !item.containsKey('onlineTime'))">
      when a.id=#{item.id} then #{item.onlineTime}
      </if>
      </foreach>
      </trim>
      <trim prefix="offlineTime=(case" suffix="ELSE offlineTime end),">
      <foreach collection="data.dataList" item="item" index="index" separator="" >
      <if test="(colPickMode==0 and item.containsKey('offlineTime')) or (colPickMode==1 and !item.containsKey('offlineTime'))">
      when a.id=#{item.id} then #{item.offlineTime}
      </if>
      </foreach>
      </trim>
      <trim prefix="source=(case" suffix="ELSE source end),">
      <foreach collection="data.dataList" item="item" index="index" separator="" >
      <choose>
      ......@@ -459,65 +576,6 @@
      </if>
      </foreach>
      </trim>
      <trim prefix="deviceFirmId=(case" suffix="ELSE deviceFirmId end),">
      <foreach collection="data.dataList" item="item" index="index" separator="" >
      <choose>
      <when test="(colPickMode==0 and item.containsKey('deviceFirmId')) or (colPickMode==1 and !item.containsKey('deviceFirmId'))">
      when a.id=#{item.id} then #{item.deviceFirmId}
      </when>
      <when test="(colPickMode==0 and item.containsKey('deviceFirmIdIncrement')) or (colPickMode==1 and !item.containsKey('deviceFirmIdIncrement'))">
      when a.id=#{item.id} then ifnull(a.deviceFirmId,0) + #{item.deviceFirmIdIncrement}
      </when>
      </choose>
      </foreach>
      </trim>
      <trim prefix="deviceFirmname=(case" suffix="ELSE deviceFirmname end),">
      <foreach collection="data.dataList" item="item" index="index" separator="" >
      <if test="(colPickMode==0 and item.containsKey('deviceFirmname')) or (colPickMode==1 and !item.containsKey('deviceFirmname'))">
      when a.id=#{item.id} then #{item.deviceFirmname}
      </if>
      </foreach>
      </trim>
      <trim prefix="ip=(case" suffix="ELSE ip end),">
      <foreach collection="data.dataList" item="item" index="index" separator="" >
      <if test="(colPickMode==0 and item.containsKey('ip')) or (colPickMode==1 and !item.containsKey('ip'))">
      when a.id=#{item.id} then #{item.ip}
      </if>
      </foreach>
      </trim>
      <trim prefix="port=(case" suffix="ELSE port end),">
      <foreach collection="data.dataList" item="item" index="index" separator="" >
      <if test="(colPickMode==0 and item.containsKey('port')) or (colPickMode==1 and !item.containsKey('port'))">
      when a.id=#{item.id} then #{item.port}
      </if>
      </foreach>
      </trim>
      <trim prefix="enabled=(case" suffix="ELSE enabled end),">
      <foreach collection="data.dataList" item="item" index="index" separator="" >
      <choose>
      <when test="(colPickMode==0 and item.containsKey('enabled')) or (colPickMode==1 and !item.containsKey('enabled'))">
      when a.id=#{item.id} then #{item.enabled}
      </when>
      <when test="(colPickMode==0 and item.containsKey('enabledIncrement')) or (colPickMode==1 and !item.containsKey('enabledIncrement'))">
      when a.id=#{item.id} then ifnull(a.enabled,0) + #{item.enabledIncrement}
      </when>
      </choose>
      </foreach>
      </trim>
      <trim prefix="onlineTime=(case" suffix="ELSE onlineTime end),">
      <foreach collection="data.dataList" item="item" index="index" separator="" >
      <if test="(colPickMode==0 and item.containsKey('onlineTime')) or (colPickMode==1 and !item.containsKey('onlineTime'))">
      when a.id=#{item.id} then #{item.onlineTime}
      </if>
      </foreach>
      </trim>
      <trim prefix="offlineTime=(case" suffix="ELSE offlineTime end),">
      <foreach collection="data.dataList" item="item" index="index" separator="" >
      <if test="(colPickMode==0 and item.containsKey('offlineTime')) or (colPickMode==1 and !item.containsKey('offlineTime'))">
      when a.id=#{item.id} then #{item.offlineTime}
      </if>
      </foreach>
      </trim>
      </trim>
      where id in
      <foreach collection="data.dataList" item="item" index="index" open="(" separator="," close=")">
      ......@@ -820,8 +878,125 @@
      #{item}
      </foreach>
      </if>
      <if test="conditionParamRef.containsKey('productCode')">
      <if test="conditionParamRef.containsKey('deviceFirmId')">
      <if test="conditionParamRef.deviceFirmId != null ">
      ${_conditionType_} a.deviceFirmId = #{${_conditionParam_}.deviceFirmId}
      </if>
      <if test="conditionParamRef.deviceFirmId == null">
      ${_conditionType_} a.deviceFirmId is null
      </if>
      </if>
      <if test="conditionParamRef.containsKey('deviceFirmIdList') and conditionParamRef.deviceFirmIdList.size() > 0">
      ${_conditionType_} a.deviceFirmId in
      <foreach collection="conditionParamRef.deviceFirmIdList" open="(" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      </if>
      <if test="conditionParamRef.containsKey('deviceFirmIdNotList') and conditionParamRef.deviceFirmIdNotList.size() > 0">
      ${_conditionType_} a.deviceFirmId not in
      <foreach collection="conditionParamRef.deviceFirmIdNotList" open="(" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      </if>
      <if test="conditionParamRef.containsKey('deviceFirmIdStart') and conditionParamRef.deviceFirmIdStart != null">
      ${_conditionType_} a.deviceFirmId <![CDATA[ >= ]]> #{${_conditionParam_}.deviceFirmIdStart}
      </if>
      <if test="conditionParamRef.containsKey('deviceFirmIdEnd') and conditionParamRef.deviceFirmIdEnd != null">
      ${_conditionType_} a.deviceFirmId <![CDATA[ <= ]]> #{${_conditionParam_}.deviceFirmIdEnd}
      </if>
      <if test="conditionParamRef.containsKey('deviceFirmname')">
      <if test="conditionParamRef.deviceFirmname != null and conditionParamRef.deviceFirmname != ''">
      ${_conditionType_} a.deviceFirmname like #{${_conditionParam_}.deviceFirmname}
      </if>
      <if test="conditionParamRef.deviceFirmname == null">
      ${_conditionType_} a.deviceFirmname is null
      </if>
      </if>
      <if test="conditionParamRef.containsKey('deviceFirmnameList') and conditionParamRef.deviceFirmnameList.size() > 0">
      ${_conditionType_} a.deviceFirmname in
      <foreach collection="conditionParamRef.deviceFirmnameList" open="(" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      </if>
      <if test="conditionParamRef.containsKey('deviceFirmnameNotList') and conditionParamRef.deviceFirmnameNotList.size() > 0">
      ${_conditionType_} a.deviceFirmname not in
      <foreach collection="conditionParamRef.deviceFirmnameNotList" open="(" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      </if>
      <if test="conditionParamRef.containsKey('ip')">
      <if test="conditionParamRef.ip != null and conditionParamRef.ip != ''">
      ${_conditionType_} a.ip like #{${_conditionParam_}.ip}
      </if>
      <if test="conditionParamRef.ip == null">
      ${_conditionType_} a.ip is null
      </if>
      </if>
      <if test="conditionParamRef.containsKey('ipList') and conditionParamRef.ipList.size() > 0">
      ${_conditionType_} a.ip in
      <foreach collection="conditionParamRef.ipList" open="(" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      </if>
      <if test="conditionParamRef.containsKey('ipNotList') and conditionParamRef.ipNotList.size() > 0">
      ${_conditionType_} a.ip not in
      <foreach collection="conditionParamRef.ipNotList" open="(" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      </if>
      <if test="conditionParamRef.containsKey('port')">
      <if test="conditionParamRef.port != null and conditionParamRef.port != ''">
      ${_conditionType_} a.port like #{${_conditionParam_}.port}
      </if>
      <if test="conditionParamRef.port == null">
      ${_conditionType_} a.port is null
      </if>
      </if>
      <if test="conditionParamRef.containsKey('portList') and conditionParamRef.portList.size() > 0">
      ${_conditionType_} a.port in
      <foreach collection="conditionParamRef.portList" open="(" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      </if>
      <if test="conditionParamRef.containsKey('portNotList') and conditionParamRef.portNotList.size() > 0">
      ${_conditionType_} a.port not in
      <foreach collection="conditionParamRef.portNotList" open="(" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      </if>
      <if test="conditionParamRef.containsKey('enabled')">
      <if test="conditionParamRef.enabled != null ">
      ${_conditionType_} a.enabled = #{${_conditionParam_}.enabled}
      </if>
      <if test="conditionParamRef.enabled == null">
      ${_conditionType_} a.enabled is null
      </if>
      </if>
      <if test="conditionParamRef.containsKey('enabledList') and conditionParamRef.enabledList.size() > 0">
      ${_conditionType_} a.enabled in
      <foreach collection="conditionParamRef.enabledList" open="(" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      </if>
      <if test="conditionParamRef.containsKey('enabledNotList') and conditionParamRef.enabledNotList.size() > 0">
      ${_conditionType_} a.enabled not in
      <foreach collection="conditionParamRef.enabledNotList" open="(" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      </if>
      <if test="conditionParamRef.containsKey('enabledStart') and conditionParamRef.enabledStart != null">
      ${_conditionType_} a.enabled <![CDATA[ >= ]]> #{${_conditionParam_}.enabledStart}
      </if>
      <if test="conditionParamRef.containsKey('enabledEnd') and conditionParamRef.enabledEnd != null">
      ${_conditionType_} a.enabled <![CDATA[ <= ]]> #{${_conditionParam_}.enabledEnd}
      </if>
      <if test="conditionParamRef.containsKey('productCode')">
      <if test="conditionParamRef.productCode != null and conditionParamRef.productCode != ''">
      ${_conditionType_} a.productCode like #{${_conditionParam_}.productCode}
      </if>
      ......@@ -1021,6 +1196,111 @@
      #{item}
      </foreach>
      </if>
      <if test="conditionParamRef.containsKey('belong')">
      <if test="conditionParamRef.belong != null and conditionParamRef.belong != ''">
      ${_conditionType_} a.belong like #{${_conditionParam_}.belong}
      </if>
      <if test="conditionParamRef.belong == null">
      ${_conditionType_} a.belong is null
      </if>
      </if>
      <if test="conditionParamRef.containsKey('belongList') and conditionParamRef.belongList.size() > 0">
      ${_conditionType_} a.belong in
      <foreach collection="conditionParamRef.belongList" open="(" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      </if>
      <if test="conditionParamRef.containsKey('belongNotList') and conditionParamRef.belongNotList.size() > 0">
      ${_conditionType_} a.belong not in
      <foreach collection="conditionParamRef.belongNotList" open="(" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      </if>
      <if test="conditionParamRef.containsKey('deviceInBuilding')">
      <if test="conditionParamRef.deviceInBuilding != null ">
      ${_conditionType_} a.deviceInBuilding = #{${_conditionParam_}.deviceInBuilding}
      </if>
      <if test="conditionParamRef.deviceInBuilding == null">
      ${_conditionType_} a.deviceInBuilding is null
      </if>
      </if>
      <if test="conditionParamRef.containsKey('deviceInBuildingList') and conditionParamRef.deviceInBuildingList.size() > 0">
      ${_conditionType_} a.deviceInBuilding in
      <foreach collection="conditionParamRef.deviceInBuildingList" open="(" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      </if>
      <if test="conditionParamRef.containsKey('deviceInBuildingNotList') and conditionParamRef.deviceInBuildingNotList.size() > 0">
      ${_conditionType_} a.deviceInBuilding not in
      <foreach collection="conditionParamRef.deviceInBuildingNotList" open="(" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      </if>
      <if test="conditionParamRef.containsKey('deviceInBuildingStart') and conditionParamRef.deviceInBuildingStart != null">
      ${_conditionType_} a.deviceInBuilding <![CDATA[ >= ]]> #{${_conditionParam_}.deviceInBuildingStart}
      </if>
      <if test="conditionParamRef.containsKey('deviceInBuildingEnd') and conditionParamRef.deviceInBuildingEnd != null">
      ${_conditionType_} a.deviceInBuilding <![CDATA[ <= ]]> #{${_conditionParam_}.deviceInBuildingEnd}
      </if>
      <if test="conditionParamRef.containsKey('deviceInFloor')">
      <if test="conditionParamRef.deviceInFloor != null ">
      ${_conditionType_} a.deviceInFloor = #{${_conditionParam_}.deviceInFloor}
      </if>
      <if test="conditionParamRef.deviceInFloor == null">
      ${_conditionType_} a.deviceInFloor is null
      </if>
      </if>
      <if test="conditionParamRef.containsKey('deviceInFloorList') and conditionParamRef.deviceInFloorList.size() > 0">
      ${_conditionType_} a.deviceInFloor in
      <foreach collection="conditionParamRef.deviceInFloorList" open="(" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      </if>
      <if test="conditionParamRef.containsKey('deviceInFloorNotList') and conditionParamRef.deviceInFloorNotList.size() > 0">
      ${_conditionType_} a.deviceInFloor not in
      <foreach collection="conditionParamRef.deviceInFloorNotList" open="(" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      </if>
      <if test="conditionParamRef.containsKey('deviceInFloorStart') and conditionParamRef.deviceInFloorStart != null">
      ${_conditionType_} a.deviceInFloor <![CDATA[ >= ]]> #{${_conditionParam_}.deviceInFloorStart}
      </if>
      <if test="conditionParamRef.containsKey('deviceInFloorEnd') and conditionParamRef.deviceInFloorEnd != null">
      ${_conditionType_} a.deviceInFloor <![CDATA[ <= ]]> #{${_conditionParam_}.deviceInFloorEnd}
      </if>
      <if test="conditionParamRef.containsKey('onlineTime')">
      <if test="conditionParamRef.onlineTime != null ">
      ${_conditionType_} a.onlineTime = #{${_conditionParam_}.onlineTime}
      </if>
      <if test="conditionParamRef.onlineTime == null">
      ${_conditionType_} a.onlineTime is null
      </if>
      </if>
      <if test="conditionParamRef.containsKey('onlineTimeStart') and conditionParamRef.onlineTimeStart != null and conditionParamRef.onlineTimeStart!=''">
      ${_conditionType_} a.onlineTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.onlineTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
      </if>
      <if test="conditionParamRef.containsKey('onlineTimeEnd') and conditionParamRef.onlineTimeEnd != null and conditionParamRef.onlineTimeEnd!=''">
      ${_conditionType_} a.onlineTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.onlineTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
      </if>
      <if test="conditionParamRef.containsKey('offlineTime')">
      <if test="conditionParamRef.offlineTime != null ">
      ${_conditionType_} a.offlineTime = #{${_conditionParam_}.offlineTime}
      </if>
      <if test="conditionParamRef.offlineTime == null">
      ${_conditionType_} a.offlineTime is null
      </if>
      </if>
      <if test="conditionParamRef.containsKey('offlineTimeStart') and conditionParamRef.offlineTimeStart != null and conditionParamRef.offlineTimeStart!=''">
      ${_conditionType_} a.offlineTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.offlineTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
      </if>
      <if test="conditionParamRef.containsKey('offlineTimeEnd') and conditionParamRef.offlineTimeEnd != null and conditionParamRef.offlineTimeEnd!=''">
      ${_conditionType_} a.offlineTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.offlineTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
      </if>
      <if test="conditionParamRef.containsKey('source')">
      <if test="conditionParamRef.source != null ">
      ${_conditionType_} a.source = #{${_conditionParam_}.source}
      ......@@ -1132,165 +1412,186 @@
      <if test="conditionParamRef.containsKey('updateTimeEnd') and conditionParamRef.updateTimeEnd != null and conditionParamRef.updateTimeEnd!=''">
      ${_conditionType_} a.updateTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
      </if>
      <if test="conditionParamRef.containsKey('deviceFirmId')">
      <if test="conditionParamRef.deviceFirmId != null ">
      ${_conditionType_} a.deviceFirmId = #{${_conditionParam_}.deviceFirmId}
      </sql>
      <sql id="_orderCols_">
      <if test="orderColList != null and !orderColList.isEmpty()">
      order by
      <if test="conditionParamRef.containsKey('idList') and conditionParamRef.idList.size() > 0">
      field(a.id,
      <foreach collection="conditionParamRef.idList" open="" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      ,
      </if>
      <if test="conditionParamRef.deviceFirmId == null">
      ${_conditionType_} a.deviceFirmId is null
      <if test="conditionParamRef.containsKey('deviceIdList') and conditionParamRef.deviceIdList.size() > 0">
      field(a.deviceId,
      <foreach collection="conditionParamRef.deviceIdList" open="" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      ,
      </if>
      <if test="conditionParamRef.containsKey('siteIdList') and conditionParamRef.siteIdList.size() > 0">
      field(a.siteId,
      <foreach collection="conditionParamRef.siteIdList" open="" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      ,
      </if>
      <if test="conditionParamRef.containsKey('deviceFirmIdList') and conditionParamRef.deviceFirmIdList.size() > 0">
      ${_conditionType_} a.deviceFirmId in
      <foreach collection="conditionParamRef.deviceFirmIdList" open="(" close=")" index="index" item="item" separator=",">
      field(a.deviceFirmId,
      <foreach collection="conditionParamRef.deviceFirmIdList" open="" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      ,
      </if>
      <if test="conditionParamRef.containsKey('deviceFirmIdNotList') and conditionParamRef.deviceFirmIdNotList.size() > 0">
      ${_conditionType_} a.deviceFirmId not in
      <foreach collection="conditionParamRef.deviceFirmIdNotList" open="(" close=")" index="index" item="item" separator=",">
      <if test="conditionParamRef.containsKey('enabledList') and conditionParamRef.enabledList.size() > 0">
      field(a.enabled,
      <foreach collection="conditionParamRef.enabledList" open="" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      ,
      </if>
      <if test="conditionParamRef.containsKey('deviceFirmIdStart') and conditionParamRef.deviceFirmIdStart != null">
      ${_conditionType_} a.deviceFirmId <![CDATA[ >= ]]> #{${_conditionParam_}.deviceFirmIdStart}
      </if>
      <if test="conditionParamRef.containsKey('deviceFirmIdEnd') and conditionParamRef.deviceFirmIdEnd != null">
      ${_conditionType_} a.deviceFirmId <![CDATA[ <= ]]> #{${_conditionParam_}.deviceFirmIdEnd}
      </if>
      <if test="conditionParamRef.containsKey('deviceFirmname')">
      <if test="conditionParamRef.deviceFirmname != null and conditionParamRef.deviceFirmname != ''">
      ${_conditionType_} a.deviceFirmname like #{${_conditionParam_}.deviceFirmname}
      </if>
      <if test="conditionParamRef.deviceFirmname == null">
      ${_conditionType_} a.deviceFirmname is null
      </if>
      </if>
      <if test="conditionParamRef.containsKey('deviceFirmnameList') and conditionParamRef.deviceFirmnameList.size() > 0">
      ${_conditionType_} a.deviceFirmname in
      <foreach collection="conditionParamRef.deviceFirmnameList" open="(" close=")" index="index" item="item" separator=",">
      <if test="conditionParamRef.containsKey('deviceSrcList') and conditionParamRef.deviceSrcList.size() > 0">
      field(a.deviceSrc,
      <foreach collection="conditionParamRef.deviceSrcList" open="" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      ,
      </if>
      <if test="conditionParamRef.containsKey('deviceFirmnameNotList') and conditionParamRef.deviceFirmnameNotList.size() > 0">
      ${_conditionType_} a.deviceFirmname not in
      <foreach collection="conditionParamRef.deviceFirmnameNotList" open="(" close=")" index="index" item="item" separator=",">
      <if test="conditionParamRef.containsKey('deviceStatusList') and conditionParamRef.deviceStatusList.size() > 0">
      field(a.deviceStatus,
      <foreach collection="conditionParamRef.deviceStatusList" open="" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      ,
      </if>
      <if test="conditionParamRef.containsKey('ip')">
      <if test="conditionParamRef.ip != null and conditionParamRef.ip != ''">
      ${_conditionType_} a.ip like #{${_conditionParam_}.ip}
      </if>
      <if test="conditionParamRef.ip == null">
      ${_conditionType_} a.ip is null
      </if>
      <if test="conditionParamRef.containsKey('deviceInBuildingList') and conditionParamRef.deviceInBuildingList.size() > 0">
      field(a.deviceInBuilding,
      <foreach collection="conditionParamRef.deviceInBuildingList" open="" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      ,
      </if>
      <if test="conditionParamRef.containsKey('ipList') and conditionParamRef.ipList.size() > 0">
      ${_conditionType_} a.ip in
      <foreach collection="conditionParamRef.ipList" open="(" close=")" index="index" item="item" separator=",">
      <if test="conditionParamRef.containsKey('deviceInFloorList') and conditionParamRef.deviceInFloorList.size() > 0">
      field(a.deviceInFloor,
      <foreach collection="conditionParamRef.deviceInFloorList" open="" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      ,
      </if>
      <if test="conditionParamRef.containsKey('ipNotList') and conditionParamRef.ipNotList.size() > 0">
      ${_conditionType_} a.ip not in
      <foreach collection="conditionParamRef.ipNotList" open="(" close=")" index="index" item="item" separator=",">
      <if test="conditionParamRef.containsKey('sourceList') and conditionParamRef.sourceList.size() > 0">
      field(a.source,
      <foreach collection="conditionParamRef.sourceList" open="" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      ,
      </if>
      <if test="conditionParamRef.containsKey('port')">
      <if test="conditionParamRef.port != null and conditionParamRef.port != ''">
      ${_conditionType_} a.port like #{${_conditionParam_}.port}
      <if test="conditionParamRef.containsKey('createUserIdList') and conditionParamRef.createUserIdList.size() > 0">
      field(a.createUserId,
      <foreach collection="conditionParamRef.createUserIdList" open="" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      ,
      </if>
      <if test="conditionParamRef.port == null">
      ${_conditionType_} a.port is null
      <if test="conditionParamRef.containsKey('updateUserIdList') and conditionParamRef.updateUserIdList.size() > 0">
      field(a.updateUserId,
      <foreach collection="conditionParamRef.updateUserIdList" open="" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      ,
      </if>
      <trim suffixOverrides="," suffix="">
      <foreach collection="orderColList" open="" close="" index="index" item="item" separator=",">
      a.${item.colName} ${item.sortKind}
      </foreach>
      </trim>
      </if>
      <if test="conditionParamRef.containsKey('portList') and conditionParamRef.portList.size() > 0">
      ${_conditionType_} a.port in
      <foreach collection="conditionParamRef.portList" open="(" close=")" index="index" item="item" separator=",">
      <if test="(orderColList == null or orderColList.isEmpty()) and orderCol != null and !orderCol.isEmpty()">
      order by
      <if test="conditionParamRef.containsKey('idList') and conditionParamRef.idList.size() > 0">
      field(a.id,
      <foreach collection="conditionParamRef.idList" open="" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      ,
      </if>
      <if test="conditionParamRef.containsKey('portNotList') and conditionParamRef.portNotList.size() > 0">
      ${_conditionType_} a.port not in
      <foreach collection="conditionParamRef.portNotList" open="(" close=")" index="index" item="item" separator=",">
      <if test="conditionParamRef.containsKey('deviceIdList') and conditionParamRef.deviceIdList.size() > 0">
      field(a.deviceId,
      <foreach collection="conditionParamRef.deviceIdList" open="" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      ,
      </if>
      <if test="conditionParamRef.containsKey('enabled')">
      <if test="conditionParamRef.enabled != null ">
      ${_conditionType_} a.enabled = #{${_conditionParam_}.enabled}
      </if>
      <if test="conditionParamRef.enabled == null">
      ${_conditionType_} a.enabled is null
      <if test="conditionParamRef.containsKey('siteIdList') and conditionParamRef.siteIdList.size() > 0">
      field(a.siteId,
      <foreach collection="conditionParamRef.siteIdList" open="" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      ,
      </if>
      <if test="conditionParamRef.containsKey('deviceFirmIdList') and conditionParamRef.deviceFirmIdList.size() > 0">
      field(a.deviceFirmId,
      <foreach collection="conditionParamRef.deviceFirmIdList" open="" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      ,
      </if>
      <if test="conditionParamRef.containsKey('enabledList') and conditionParamRef.enabledList.size() > 0">
      ${_conditionType_} a.enabled in
      <foreach collection="conditionParamRef.enabledList" open="(" close=")" index="index" item="item" separator=",">
      field(a.enabled,
      <foreach collection="conditionParamRef.enabledList" open="" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      ,
      </if>
      <if test="conditionParamRef.containsKey('enabledNotList') and conditionParamRef.enabledNotList.size() > 0">
      ${_conditionType_} a.enabled not in
      <foreach collection="conditionParamRef.enabledNotList" open="(" close=")" index="index" item="item" separator=",">
      <if test="conditionParamRef.containsKey('deviceSrcList') and conditionParamRef.deviceSrcList.size() > 0">
      field(a.deviceSrc,
      <foreach collection="conditionParamRef.deviceSrcList" open="" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      ,
      </if>
      <if test="conditionParamRef.containsKey('enabledStart') and conditionParamRef.enabledStart != null">
      ${_conditionType_} a.enabled <![CDATA[ >= ]]> #{${_conditionParam_}.enabledStart}
      </if>
      <if test="conditionParamRef.containsKey('enabledEnd') and conditionParamRef.enabledEnd != null">
      ${_conditionType_} a.enabled <![CDATA[ <= ]]> #{${_conditionParam_}.enabledEnd}
      </if>
      <if test="conditionParamRef.containsKey('onlineTime')">
      <if test="conditionParamRef.onlineTime != null ">
      ${_conditionType_} a.onlineTime = #{${_conditionParam_}.onlineTime}
      </if>
      <if test="conditionParamRef.onlineTime == null">
      ${_conditionType_} a.onlineTime is null
      </if>
      </if>
      <if test="conditionParamRef.containsKey('onlineTimeStart') and conditionParamRef.onlineTimeStart != null and conditionParamRef.onlineTimeStart!=''">
      ${_conditionType_} a.onlineTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.onlineTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
      </if>
      <if test="conditionParamRef.containsKey('onlineTimeEnd') and conditionParamRef.onlineTimeEnd != null and conditionParamRef.onlineTimeEnd!=''">
      ${_conditionType_} a.onlineTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.onlineTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
      </if>
      <if test="conditionParamRef.containsKey('offlineTime')">
      <if test="conditionParamRef.offlineTime != null ">
      ${_conditionType_} a.offlineTime = #{${_conditionParam_}.offlineTime}
      <if test="conditionParamRef.containsKey('deviceStatusList') and conditionParamRef.deviceStatusList.size() > 0">
      field(a.deviceStatus,
      <foreach collection="conditionParamRef.deviceStatusList" open="" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      ,
      </if>
      <if test="conditionParamRef.offlineTime == null">
      ${_conditionType_} a.offlineTime is null
      <if test="conditionParamRef.containsKey('deviceInBuildingList') and conditionParamRef.deviceInBuildingList.size() > 0">
      field(a.deviceInBuilding,
      <foreach collection="conditionParamRef.deviceInBuildingList" open="" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      ,
      </if>
      <if test="conditionParamRef.containsKey('deviceInFloorList') and conditionParamRef.deviceInFloorList.size() > 0">
      field(a.deviceInFloor,
      <foreach collection="conditionParamRef.deviceInFloorList" open="" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      ,
      </if>
      <if test="conditionParamRef.containsKey('offlineTimeStart') and conditionParamRef.offlineTimeStart != null and conditionParamRef.offlineTimeStart!=''">
      ${_conditionType_} a.offlineTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.offlineTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
      <if test="conditionParamRef.containsKey('sourceList') and conditionParamRef.sourceList.size() > 0">
      field(a.source,
      <foreach collection="conditionParamRef.sourceList" open="" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      ,
      </if>
      <if test="conditionParamRef.containsKey('offlineTimeEnd') and conditionParamRef.offlineTimeEnd != null and conditionParamRef.offlineTimeEnd!=''">
      ${_conditionType_} a.offlineTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.offlineTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
      <if test="conditionParamRef.containsKey('createUserIdList') and conditionParamRef.createUserIdList.size() > 0">
      field(a.createUserId,
      <foreach collection="conditionParamRef.createUserIdList" open="" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      ,
      </if>
      </sql>
      <sql id="_orderCols_">
      <if test="orderColList != null and !orderColList.isEmpty()">
      order by
      <trim suffixOverrides="," suffix="">
      <foreach collection="orderColList" open="" close="" index="index" item="item" separator=",">
      ${item.colName} ${item.sortKind}
      <if test="conditionParamRef.containsKey('updateUserIdList') and conditionParamRef.updateUserIdList.size() > 0">
      field(a.updateUserId,
      <foreach collection="conditionParamRef.updateUserIdList" open="" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      </trim>
      ,
      </if>
      <if test="(orderColList == null or orderColList.isEmpty()) and orderCol != null and !orderCol.isEmpty()">
      order by
      <trim suffixOverrides="," suffix="">
      <if test="orderCol.containsKey('id')">
      a.id
      ......@@ -1332,6 +1633,31 @@
      <if test='orderCol.siteName != null and "DESC".equalsIgnoreCase(orderCol.siteName)'>DESC</if>
      ,
      </if>
      <if test="orderCol.containsKey('deviceFirmId')">
      a.deviceFirmId
      <if test='orderCol.deviceFirmId != null and "DESC".equalsIgnoreCase(orderCol.deviceFirmId)'>DESC</if>
      ,
      </if>
      <if test="orderCol.containsKey('deviceFirmname')">
      a.deviceFirmname
      <if test='orderCol.deviceFirmname != null and "DESC".equalsIgnoreCase(orderCol.deviceFirmname)'>DESC</if>
      ,
      </if>
      <if test="orderCol.containsKey('ip')">
      a.ip
      <if test='orderCol.ip != null and "DESC".equalsIgnoreCase(orderCol.ip)'>DESC</if>
      ,
      </if>
      <if test="orderCol.containsKey('port')">
      a.port
      <if test='orderCol.port != null and "DESC".equalsIgnoreCase(orderCol.port)'>DESC</if>
      ,
      </if>
      <if test="orderCol.containsKey('enabled')">
      a.enabled
      <if test='orderCol.enabled != null and "DESC".equalsIgnoreCase(orderCol.enabled)'>DESC</if>
      ,
      </if>
      <if test="orderCol.containsKey('productCode')">
      a.productCode
      <if test='orderCol.productCode != null and "DESC".equalsIgnoreCase(orderCol.productCode)'>DESC</if>
      ......@@ -1377,6 +1703,31 @@
      <if test='orderCol.deviceRemark != null and "DESC".equalsIgnoreCase(orderCol.deviceRemark)'>DESC</if>
      ,
      </if>
      <if test="orderCol.containsKey('belong')">
      a.belong
      <if test='orderCol.belong != null and "DESC".equalsIgnoreCase(orderCol.belong)'>DESC</if>
      ,
      </if>
      <if test="orderCol.containsKey('deviceInBuilding')">
      a.deviceInBuilding
      <if test='orderCol.deviceInBuilding != null and "DESC".equalsIgnoreCase(orderCol.deviceInBuilding)'>DESC</if>
      ,
      </if>
      <if test="orderCol.containsKey('deviceInFloor')">
      a.deviceInFloor
      <if test='orderCol.deviceInFloor != null and "DESC".equalsIgnoreCase(orderCol.deviceInFloor)'>DESC</if>
      ,
      </if>
      <if test="orderCol.containsKey('onlineTime')">
      a.onlineTime
      <if test='orderCol.onlineTime != null and "DESC".equalsIgnoreCase(orderCol.onlineTime)'>DESC</if>
      ,
      </if>
      <if test="orderCol.containsKey('offlineTime')">
      a.offlineTime
      <if test='orderCol.offlineTime != null and "DESC".equalsIgnoreCase(orderCol.offlineTime)'>DESC</if>
      ,
      </if>
      <if test="orderCol.containsKey('source')">
      a.source
      <if test='orderCol.source != null and "DESC".equalsIgnoreCase(orderCol.source)'>DESC</if>
      ......@@ -1402,43 +1753,10 @@
      <if test='orderCol.updateTime != null and "DESC".equalsIgnoreCase(orderCol.updateTime)'>DESC</if>
      ,
      </if>
      <if test="orderCol.containsKey('deviceFirmId')">
      a.deviceFirmId
      <if test='orderCol.deviceFirmId != null and "DESC".equalsIgnoreCase(orderCol.deviceFirmId)'>DESC</if>
      ,
      </if>
      <if test="orderCol.containsKey('deviceFirmname')">
      a.deviceFirmname
      <if test='orderCol.deviceFirmname != null and "DESC".equalsIgnoreCase(orderCol.deviceFirmname)'>DESC</if>
      ,
      </if>
      <if test="orderCol.containsKey('ip')">
      a.ip
      <if test='orderCol.ip != null and "DESC".equalsIgnoreCase(orderCol.ip)'>DESC</if>
      ,
      </if>
      <if test="orderCol.containsKey('port')">
      a.port
      <if test='orderCol.port != null and "DESC".equalsIgnoreCase(orderCol.port)'>DESC</if>
      ,
      </if>
      <if test="orderCol.containsKey('enabled')">
      a.enabled
      <if test='orderCol.enabled != null and "DESC".equalsIgnoreCase(orderCol.enabled)'>DESC</if>
      ,
      </if>
      <if test="orderCol.containsKey('onlineTime')">
      a.onlineTime
      <if test='orderCol.onlineTime != null and "DESC".equalsIgnoreCase(orderCol.onlineTime)'>DESC</if>
      ,
      </if>
      <if test="orderCol.containsKey('offlineTime')">
      a.offlineTime
      <if test='orderCol.offlineTime != null and "DESC".equalsIgnoreCase(orderCol.offlineTime)'>DESC</if>
      ,
      </if>
      </trim>
      </if>
      </sql>
      <sql id="_group_by_">
      <if test="groupList != null and !groupList.isEmpty()">
      ......
      Markdown is supported
      0% or
      You are about to add 0 people to the discussion. Proceed with caution.
      Finish editing this message first!
      Please register or to comment