添加同步预约和注册用户类

db/module.sql

@@ -16,12 +16,17 @@ CREATE TABLE mortals_xhx_realtime_dataflow(
     `queueNum` varchar(255) NOT NULL     COMMENT '排队编码',
     `location` varchar(255) NOT NULL     COMMENT '办理位置',
     `picture` varchar(255)      COMMENT '识别截图',
+    `picUri` varchar(255)      COMMENT '相对图片pic',
+    `serverIndexCode` varchar(255)      COMMENT '图片资源唯一标识',
+    `eventId` varchar(255)      COMMENT '事件id',
+    `eventType` bigint(20) NOT NULL     COMMENT '事件类型',
     `createTime` datetime      COMMENT '创建时间',
     `createUserId` bigint(20)      COMMENT '创建人id',
     `updateTime` datetime      COMMENT '更新时间',
     `updateUserId` bigint(20)      COMMENT '更新人id',
 PRIMARY KEY  (`id`)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='人员发现记录';
+
 -- ----------------------------
 -- 预约签到记录表
 -- ----------------------------

refined-manager/src/main/java/com/mortals/xhx/common/code/HikAbilityEnum.java

+package com.mortals.xhx.common.code;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+/**
+* 海康事件类型
+*
+* @author zxfei
+*/
+public enum HikAbilityEnum {
+    人脸识别事件("event_face_recognition", "人脸识别事件");
+    private String value;
+    private String desc;
+
+    HikAbilityEnum(String value, String desc) {
+        this.value = value;
+        this.desc = desc;
+    }
+
+    public String getValue() {
+        return this.value;
+    }
+
+    public String getDesc() {
+        return this.desc;
+    }
+
+    public static HikAbilityEnum getByValue(String value) {
+        for (HikAbilityEnum recognitionPlanTypeEnum : HikAbilityEnum.values()) {
+            if (recognitionPlanTypeEnum.getValue() == value) {
+                return recognitionPlanTypeEnum;
+            }
+        }
+        return null;
+    }
+
+    /**
+    * 获取Map集合
+    *
+    * @param eItem 不包含项
+    * @return
+    */
+    public static Map<String, String> getEnumMap(String... eItem) {
+        Map<String, String> resultMap = new LinkedHashMap<>();
+        for (HikAbilityEnum item : HikAbilityEnum.values()) {
+            try {
+                boolean hasE = false;
+                for (String e : eItem) {
+                    if (item.getValue() == e) {
+                        hasE = true;
+                        break;
+                    }
+                }
+                if (!hasE) {
+                    resultMap.put(item.getValue() + "", item.getDesc());
+                }
+            } catch (Exception ex) {
+
+            }
+        }
+        return resultMap;
+    }
+}
\ No newline at end of file

refined-manager/src/main/java/com/mortals/xhx/common/code/HikEventTypeEnum.java

@@ -4,21 +4,22 @@ import java.util.LinkedHashMap;
 import java.util.Map;
 
 /**
-* 海康事件类型
+* 周五是否监测(0.否,1.是)枚举类
 *
 * @author zxfei
 */
 public enum HikEventTypeEnum {
-    重点人员识别事件("event_face_recognition", "重点人员识别事件");
-    private String value;
+    重点人员识别事件(1644175361, "重点人员识别事件"),
+    陌生人员识别事件(1644171265, "陌生人员识别事件");
+    private Integer value;
     private String desc;
 
-    HikEventTypeEnum(String value, String desc) {
+    HikEventTypeEnum(Integer value, String desc) {
         this.value = value;
         this.desc = desc;
     }
 
-    public String getValue() {
+    public Integer getValue() {
         return this.value;
     }
 
@@ -26,10 +27,10 @@ public enum HikEventTypeEnum {
         return this.desc;
     }
 
-    public static HikEventTypeEnum getByValue(String value) {
-        for (HikEventTypeEnum recognitionPlanTypeEnum : HikEventTypeEnum.values()) {
-            if (recognitionPlanTypeEnum.getValue() == value) {
-                return recognitionPlanTypeEnum;
+    public static HikEventTypeEnum getByValue(Integer value) {
+        for (HikEventTypeEnum fridayEnum : HikEventTypeEnum.values()) {
+            if (fridayEnum.getValue() == value) {
+                return fridayEnum;
             }
         }
         return null;
@@ -41,12 +42,12 @@ public enum HikEventTypeEnum {
     * @param eItem 不包含项
     * @return
     */
-    public static Map<String, String> getEnumMap(String... eItem) {
+    public static Map<String, String> getEnumMap(Integer... eItem) {
         Map<String, String> resultMap = new LinkedHashMap<>();
         for (HikEventTypeEnum item : HikEventTypeEnum.values()) {
             try {
                 boolean hasE = false;
-                for (String e : eItem) {
+                for (Integer e : eItem) {
                     if (item.getValue() == e) {
                         hasE = true;
                         break;

refined-manager/src/main/java/com/mortals/xhx/daemon/task/SyncAppointmentPersonTaskImpl.java

@@ -44,6 +44,7 @@ import java.util.stream.Collectors;
 
 /**
  * 同步预约人数。
+ * 定时每日执行，执行前删除当天已经同步的预约人
  */
 @Slf4j
 @Service("SyncAppointmentPersonTask")
@@ -93,7 +94,6 @@ public class SyncAppointmentPersonTaskImpl implements ITaskExcuteService {
                 if (restTotal.getCode() == YesNoEnum.YES.getValue()) {
                     //同步今天预约用户
                     List<AppointmentDataItem> appointUserList = restTotal.getData().getData();
-
                     log.info("预约用户总数量：{}", appointUserList.size());
                     if (!ObjectUtils.isEmpty(appointUserList)) {
                         //查询今天添加的预约 并删除
@@ -124,9 +124,8 @@ public class SyncAppointmentPersonTaskImpl implements ITaskExcuteService {
                             return appointmentPersonEntity;
                         }).collect(Collectors.toList());
 
-
                         if (!ObjectUtils.isEmpty(newUserList)) {
-                            log.info("注册用户新增，size:{}", newUserList.size());
+                            log.info("预约用户新增，size:{}", newUserList.size());
                             appointmentPersonService.save(newUserList);
                         }
                     }

refined-manager/src/main/java/com/mortals/xhx/daemon/task/SyncRegisterUserPicTaskImpl.java

@@ -29,7 +29,7 @@ import java.util.List;
 import java.util.stream.Collectors;
 
 /**
- * 同步注册用户与预约人数。
+ * 同步注册用户的证件照片。
  */
 @Slf4j
 @Service("SyncRegisterUserPicTask")

refined-manager/src/main/java/com/mortals/xhx/daemon/task/SyncRegisterUserTaskImpl.java

@@ -57,7 +57,8 @@ import java.util.Map;
 import java.util.stream.Collectors;
 
 /**
- * 同步注册用户与预约人数。
+ * 同步注册用户。
+ * 定时以一定时间间隔进行人员获取 定时时间要早于每日预约人数的同步时间
  */
 @Slf4j
 @Service("SyncRegisterUserTask")
@@ -181,10 +182,10 @@ public class SyncRegisterUserTaskImpl implements ITaskExcuteService {
                             personService.save(saveUserList);
                         }
 
-                        if (!ObjectUtils.isEmpty(delUserList)) {
-                            log.info("注册用户删除，size:{}", delUserList.size());
-                            personService.remove(delUserList, null);
-                        }
+//                        if (!ObjectUtils.isEmpty(delUserList)) {
+//                            log.info("注册用户删除，size:{}", delUserList.size());
+//                            personService.remove(delUserList, null);
+//                        }
                     }
 
 

refined-manager/src/main/java/com/mortals/xhx/daemon/task/SyncUserTaskImpl.java

@@ -22,7 +22,7 @@ import org.springframework.util.ObjectUtils;
 import java.util.List;
 
 /**
- * 同步用户,唯一标识为用户名。
+ * 同步门户用户,唯一标识为用户名。
  */
 @Slf4j
 @Service("SyncUserTask")

refined-manager/src/main/java/com/mortals/xhx/daemon/task/SyncUserToHikTaskImpl.java

@@ -41,7 +41,9 @@ import java.util.Date;
 import java.util.List;
 
 /**
- * 同步用户到海康指定库。
+ * 同步用户人脸数据到海康指定库。
+ * 时间间隔以同步注册用户之后
+ * 默认同步到一个人脸用户组，如要其它用户组 则页面上进行添加
  */
 @Slf4j
 @Service("SyncUserToHikTask")

refined-manager/src/main/java/com/mortals/xhx/module/hik/AbstractHikService.java

@@ -17,7 +17,6 @@ public abstract class AbstractHikService {
     @Value("${hik.appSecret:''}")
     protected String appSecret;
 
-
     @Value("${hik.protocol:http://}")
     protected String protocol;
 

refined-manager/src/main/java/com/mortals/xhx/module/hik/event/service/impl/HikEventServiceImpl.java

@@ -7,6 +7,7 @@ import com.hikvision.artemis.sdk.config.ArtemisConfig;
 import com.mortals.framework.ap.GlobalSysInfo;
 import com.mortals.framework.common.Rest;
 import com.mortals.framework.util.DataUtil;
+import com.mortals.xhx.common.code.HikAbilityEnum;
 import com.mortals.xhx.common.code.HikEventTypeEnum;
 import com.mortals.xhx.common.key.ParamKey;
 import com.mortals.xhx.module.hik.AbstractHikService;
@@ -24,6 +25,7 @@ import org.springframework.stereotype.Service;
 
 import java.util.Date;
 import java.util.List;
+import java.util.stream.Collectors;
 
 /**
  * 海康人员接口类
@@ -111,35 +113,34 @@ public class HikEventServiceImpl extends AbstractHikService implements IHikEvent
         //String similarity = GlobalSysInfo.getParamValue(ParamKey.PARAM_FACE_SIMILARITY, "0.8");
 
         Params params = req.getParams();
-        if (HikEventTypeEnum.重点人员识别事件.getValue().equals(params.getAbility())) {
-            params.getEvents();
+        if (HikAbilityEnum.人脸识别事件.getValue().equals(params.getAbility())) {
             for (EventsItem event : params.getEvents()) {
-                //事件详细
-                String eventId = event.getEventId();
-                int eventType = event.getEventType();
                 EventData eventData = event.getData();
                 //识别结果
                 FaceRecognitionResult faceRecognitionResult = eventData.getFaceRecognitionResult();
                 //抓拍信息
                 Snap snap = faceRecognitionResult.getSnap();
-                //匹配的结果
-                List<FaceMatchItem> faceMatchs = faceRecognitionResult.getFaceMatch();
-                for (FaceMatchItem faceMatch : faceMatchs) {
+                if (HikEventTypeEnum.重点人员识别事件.getValue() == event.getEventType()) {
+                    //处理重点人员事件
+                    //匹配的结果
+                    List<FaceMatchItem> faceMatchs = faceRecognitionResult.getFaceMatch();
+                    for (FaceMatchItem faceMatch : faceMatchs) {
+                        //根据匹配结果 保存业务数据 todo
+                        if (faceMatch.getSimilarity() > similarity) {
+                            //保存当前识别结果到记录表中
+                        }
+                    }
+
+                } else if (HikEventTypeEnum.陌生人员识别事件.getValue() == event.getEventType()) {
                     //不论识别结果 保存流量数据
                     RealtimeDataflowEntity realtimeDataflowEntity = new RealtimeDataflowEntity();
+                    realtimeDataflowEntity.setDetectTime(event.getHappenTime());
+                    String resIndexCodes = eventData.getResInfo().stream().map(i -> i.getIndexCode()).collect(Collectors.joining(","));
+                    realtimeDataflowEntity.setDevice(resIndexCodes);
+                    realtimeDataflowEntity.setPicUri(eventData.getFaceRecognitionResult().getSnap().getFaceUrl());
+                    realtimeDataflowEntity.setEventId(event.getEventId());
+                    realtimeDataflowEntity.setEventType(HikEventTypeEnum.陌生人员识别事件.getValue().longValue());
 
-//                    realtimeDataflowEntity.setPersonId();
-//                    realtimeDataflowEntity.setName();
-//                    realtimeDataflowEntity.setDevice();
-//                    realtimeDataflowEntity.setDetectTime();
-//                    realtimeDataflowEntity.setContact();
-//                    realtimeDataflowEntity.setIdNumber();
-//                    realtimeDataflowEntity.setIsBooking();
-//                    realtimeDataflowEntity.setQueueNum();
-//                    realtimeDataflowEntity.setLocation();
-//                    realtimeDataflowEntity.setPicture();
-//                    realtimeDataflowEntity.setOrderCols();
-//                    realtimeDataflowEntity.setOrderColList();
 
                     realtimeDataflowEntity.setCreateUserId(1L);
                     realtimeDataflowEntity.setCreateTime(new Date());
@@ -149,14 +150,6 @@ public class HikEventServiceImpl extends AbstractHikService implements IHikEvent
                     realtimeDataflowEntity.initAttrValue();
 
                     //dataflowService.save()
-
-                    //根据匹配结果 保存业务数据 todo
-                    if(faceMatch.getSimilarity()>similarity){
-                        //保存当前识别结果到记录表中
-
-                    }else {
-                        //识别为陌生人 保存
-                    }
                 }
 
 

refined-manager/src/main/java/com/mortals/xhx/module/monitor/web/MonitorAlarmController.java

@@ -33,8 +33,6 @@ import static com.mortals.framework.ap.SysConstains.*;
 @RequestMapping("monitor/alarm")
 public class MonitorAlarmController extends BaseCRUDJsonBodyMappingController<MonitorAlarmService,MonitorAlarmEntity,Long> {
 
-    @Autowired
-    private ParamService paramService;
 
     public MonitorAlarmController(){
         super.setModuleDesc( "监测预警记录");

refined-manager/src/main/java/com/mortals/xhx/module/realtime/model/RealtimeDataflowEntity.java

@@ -8,252 +8,325 @@ import com.mortals.framework.annotation.Excel;
 import com.mortals.framework.model.BaseEntityLong;
 import com.mortals.xhx.module.realtime.model.vo.RealtimeDataflowVo;
 /**
-* 人员发现记录实体对象
-*
-* @author zxfei
-* @date 2023-04-09
-*/
+ * 人员发现记录实体对象
+ *
+ * @author zxfei
+ * @date 2023-04-16
+ */
 
 public class RealtimeDataflowEntity extends RealtimeDataflowVo {
     private static final long serialVersionUID = 1L;
 
     /**
-    * 站点Id
-    */
+     * 站点Id
+     */
     private Long siteId;
     /**
-    * 站点名称
-    */
+     * 站点名称
+     */
     private String siteName;
     /**
-    * 人员id
-    */
+     * 人员id
+     */
     @Excel(name = "人员id")
     private Long personId;
     /**
-    * 姓名
-    */
+     * 姓名
+     */
     @Excel(name = "姓名")
     private String name;
     /**
-    * 监测设备
-    */
+     * 监测设备
+     */
     @Excel(name = "监测设备")
     private String device;
     /**
-    * 监测时间
-    */
+     * 监测时间
+     */
     @Excel(name = "监测时间", width = 30, dateFormat = "yyyy-MM-dd")
     private Date detectTime;
     /**
-    * 联系方式
-    */
+     * 联系方式
+     */
     @Excel(name = "联系方式")
     private String contact;
     /**
-    * 身份证号码
-    */
+     * 身份证号码
+     */
     @Excel(name = "身份证号码")
     private String idNumber;
     /**
-    * 是否预约(0.否，1.是)
-    */
+     * 是否预约(0.否，1.是)
+     */
     @Excel(name = "是否预约", readConverterExp = "0=否,1=是")
     private Integer isBooking;
     /**
-    * 排队编码
-    */
+     * 排队编码
+     */
     @Excel(name = "排队编码")
     private String queueNum;
     /**
-    * 办理位置
-    */
+     * 办理位置
+     */
     @Excel(name = "办理位置")
     private String location;
     /**
-    * 识别截图
-    */
+     * 识别截图
+     */
     @Excel(name = "识别截图")
     private String picture;
+    /**
+     * 相对图片pic
+     */
+    private String picUri;
+    /**
+     * 图片资源唯一标识
+     */
+    private String serverIndexCode;
+    /**
+     * 事件id
+     */
+    private String eventId;
+    /**
+     * 事件类型
+     */
+    @Excel(name = "事件类型")
+    private Long eventType;
 
 
 
     public RealtimeDataflowEntity(){}
     /**
-    * 获取 站点Id
-    * @return Long
-    */
+     * 获取 站点Id
+     * @return Long
+     */
     public Long getSiteId(){
         return siteId;
     }
     /**
-    * 设置 站点Id
-    * @param siteId
-    */
+     * 设置 站点Id
+     * @param siteId
+     */
     public void setSiteId(Long siteId){
         this.siteId = siteId;
     }
     /**
-    * 获取 站点名称
-    * @return String
-    */
+     * 获取 站点名称
+     * @return String
+     */
     public String getSiteName(){
         return siteName;
     }
     /**
-    * 设置 站点名称
-    * @param siteName
-    */
+     * 设置 站点名称
+     * @param siteName
+     */
     public void setSiteName(String siteName){
         this.siteName = siteName;
     }
     /**
-    * 获取 人员id
-    * @return Long
-    */
+     * 获取 人员id
+     * @return Long
+     */
     public Long getPersonId(){
         return personId;
     }
     /**
-    * 设置 人员id
-    * @param personId
-    */
+     * 设置 人员id
+     * @param personId
+     */
     public void setPersonId(Long personId){
         this.personId = personId;
     }
     /**
-    * 获取 姓名
-    * @return String
-    */
+     * 获取 姓名
+     * @return String
+     */
     public String getName(){
         return name;
     }
     /**
-    * 设置 姓名
-    * @param name
-    */
+     * 设置 姓名
+     * @param name
+     */
     public void setName(String name){
         this.name = name;
     }
     /**
-    * 获取 监测设备
-    * @return String
-    */
+     * 获取 监测设备
+     * @return String
+     */
     public String getDevice(){
         return device;
     }
     /**
-    * 设置 监测设备
-    * @param device
-    */
+     * 设置 监测设备
+     * @param device
+     */
     public void setDevice(String device){
         this.device = device;
     }
     /**
-    * 获取 监测时间
-    * @return Date
-    */
+     * 获取 监测时间
+     * @return Date
+     */
     public Date getDetectTime(){
         return detectTime;
     }
     /**
-    * 设置 监测时间
-    * @param detectTime
-    */
+     * 设置 监测时间
+     * @param detectTime
+     */
     public void setDetectTime(Date detectTime){
         this.detectTime = detectTime;
     }
     /**
-    * 获取 联系方式
-    * @return String
-    */
+     * 获取 联系方式
+     * @return String
+     */
     public String getContact(){
         return contact;
     }
     /**
-    * 设置 联系方式
-    * @param contact
-    */
+     * 设置 联系方式
+     * @param contact
+     */
     public void setContact(String contact){
         this.contact = contact;
     }
     /**
-    * 获取 身份证号码
-    * @return String
-    */
+     * 获取 身份证号码
+     * @return String
+     */
     public String getIdNumber(){
         return idNumber;
     }
     /**
-    * 设置 身份证号码
-    * @param idNumber
-    */
+     * 设置 身份证号码
+     * @param idNumber
+     */
     public void setIdNumber(String idNumber){
         this.idNumber = idNumber;
     }
     /**
-    * 获取 是否预约(0.否，1.是)
-    * @return Integer
-    */
+     * 获取 是否预约(0.否，1.是)
+     * @return Integer
+     */
     public Integer getIsBooking(){
         return isBooking;
     }
     /**
-    * 设置 是否预约(0.否，1.是)
-    * @param isBooking
-    */
+     * 设置 是否预约(0.否，1.是)
+     * @param isBooking
+     */
     public void setIsBooking(Integer isBooking){
         this.isBooking = isBooking;
     }
     /**
-    * 获取 排队编码
-    * @return String
-    */
+     * 获取 排队编码
+     * @return String
+     */
     public String getQueueNum(){
         return queueNum;
     }
     /**
-    * 设置 排队编码
-    * @param queueNum
-    */
+     * 设置 排队编码
+     * @param queueNum
+     */
     public void setQueueNum(String queueNum){
         this.queueNum = queueNum;
     }
     /**
-    * 获取 办理位置
-    * @return String
-    */
+     * 获取 办理位置
+     * @return String
+     */
     public String getLocation(){
         return location;
     }
     /**
-    * 设置 办理位置
-    * @param location
-    */
+     * 设置 办理位置
+     * @param location
+     */
     public void setLocation(String location){
         this.location = location;
     }
     /**
-    * 获取 识别截图
-    * @return String
-    */
+     * 获取 识别截图
+     * @return String
+     */
     public String getPicture(){
         return picture;
     }
     /**
-    * 设置 识别截图
-    * @param picture
-    */
+     * 设置 识别截图
+     * @param picture
+     */
     public void setPicture(String picture){
         this.picture = picture;
     }
+    /**
+     * 获取 相对图片pic
+     * @return String
+     */
+    public String getPicUri(){
+        return picUri;
+    }
+    /**
+     * 设置 相对图片pic
+     * @param picUri
+     */
+    public void setPicUri(String picUri){
+        this.picUri = picUri;
+    }
+    /**
+     * 获取 图片资源唯一标识
+     * @return String
+     */
+    public String getServerIndexCode(){
+        return serverIndexCode;
+    }
+    /**
+     * 设置 图片资源唯一标识
+     * @param serverIndexCode
+     */
+    public void setServerIndexCode(String serverIndexCode){
+        this.serverIndexCode = serverIndexCode;
+    }
+    /**
+     * 获取 事件id
+     * @return String
+     */
+    public String getEventId(){
+        return eventId;
+    }
+    /**
+     * 设置 事件id
+     * @param eventId
+     */
+    public void setEventId(String eventId){
+        this.eventId = eventId;
+    }
+    /**
+     * 获取 事件类型
+     * @return Long
+     */
+    public Long getEventType(){
+        return eventType;
+    }
+    /**
+     * 设置 事件类型
+     * @param eventType
+     */
+    public void setEventType(Long eventType){
+        this.eventType = eventType;
+    }
 
 
 
 
     @Override
     public int hashCode() {
-         return this.getId().hashCode();
+        return this.getId().hashCode();
     }
     @Override
     public boolean equals(Object obj) {
@@ -261,7 +334,7 @@ public class RealtimeDataflowEntity extends RealtimeDataflowVo {
         if (obj instanceof RealtimeDataflowEntity) {
             RealtimeDataflowEntity tmp = (RealtimeDataflowEntity) obj;
             if (this.getId() == tmp.getId()) {
-                 return true;
+                return true;
             }
         }
         return false;
@@ -281,33 +354,45 @@ public class RealtimeDataflowEntity extends RealtimeDataflowVo {
         sb.append(",queueNum:").append(getQueueNum());
         sb.append(",location:").append(getLocation());
         sb.append(",picture:").append(getPicture());
+        sb.append(",picUri:").append(getPicUri());
+        sb.append(",serverIndexCode:").append(getServerIndexCode());
+        sb.append(",eventId:").append(getEventId());
+        sb.append(",eventType:").append(getEventType());
         return sb.toString();
     }
 
     public void initAttrValue(){
 
-            this.siteId = null;
+        this.siteId = null;
+
+        this.siteName = "";
+
+        this.personId = null;
+
+        this.name = "";
+
+        this.device = "";
 
-            this.siteName = "";
+        this.detectTime = null;
 
-            this.personId = null;
+        this.contact = "";
 
-            this.name = "";
+        this.idNumber = "";
 
-            this.device = "";
+        this.isBooking = 0;
 
-            this.detectTime = null;
+        this.queueNum = "";
 
-            this.contact = "";
+        this.location = "";
 
-            this.idNumber = "";
+        this.picture = "";
 
-            this.isBooking = 0;
+        this.picUri = "";
 
-            this.queueNum = "";
+        this.serverIndexCode = "";
 
-            this.location = "";
+        this.eventId = "";
 
-            this.picture = "";
+        this.eventType = null;
     }
 }
\ No newline at end of file

refined-manager/src/main/java/com/mortals/xhx/module/realtime/model/RealtimeDataflowQuery.java

@@ -4,11 +4,11 @@ import java.util.Date;
 import java.util.List;
 import com.mortals.xhx.module.realtime.model.RealtimeDataflowEntity;
 /**
-* 人员发现记录查询对象
-*
-* @author zxfei
-* @date 2023-04-09
-*/
+ * 人员发现记录查询对象
+ *
+ * @author zxfei
+ * @date 2023-04-16
+ */
 public class RealtimeDataflowQuery extends RealtimeDataflowEntity {
     /** 开始 主键ID，主键，自增长 */
     private Long idStart;
@@ -116,6 +116,36 @@ public class RealtimeDataflowQuery extends RealtimeDataflowEntity {
 
     /** 识别截图排除列表 */
     private List <String> pictureNotList;
+    /** 相对图片pic */
+    private List<String> picUriList;
+
+    /** 相对图片pic排除列表 */
+    private List <String> picUriNotList;
+    /** 图片资源唯一标识 */
+    private List<String> serverIndexCodeList;
+
+    /** 图片资源唯一标识排除列表 */
+    private List <String> serverIndexCodeNotList;
+    /** 事件id */
+    private List<String> eventIdList;
+
+    /** 事件id排除列表 */
+    private List <String> eventIdNotList;
+    /** 开始 事件类型 */
+    private Long eventTypeStart;
+
+    /** 结束 事件类型 */
+    private Long eventTypeEnd;
+
+    /** 增加 事件类型 */
+    private Long eventTypeIncrement;
+
+    /** 事件类型列表 */
+    private List <Long> eventTypeList;
+
+    /** 事件类型排除列表 */
+    private List <Long> eventTypeNotList;
+
     /** 开始 创建时间 */
     private String createTimeStart;
 
@@ -167,1350 +197,1638 @@ public class RealtimeDataflowQuery extends RealtimeDataflowEntity {
     public RealtimeDataflowQuery(){}
 
     /**
-    * 获取 开始 主键ID，主键，自增长
-    * @return idStart
-    */
+     * 获取 开始 主键ID，主键，自增长
+     * @return idStart
+     */
     public Long getIdStart(){
         return this.idStart;
     }
 
     /**
-    * 设置 开始 主键ID，主键，自增长
-    * @param idStart
-    */
+     * 设置 开始 主键ID，主键，自增长
+     * @param idStart
+     */
     public void setIdStart(Long idStart){
         this.idStart = idStart;
     }
 
     /**
-    * 获取 结束 主键ID，主键，自增长
-    * @return $idEnd
-    */
+     * 获取 结束 主键ID，主键，自增长
+     * @return $idEnd
+     */
     public Long getIdEnd(){
         return this.idEnd;
     }
 
     /**
-    * 设置 结束 主键ID，主键，自增长
-    * @param idEnd
-    */
+     * 设置 结束 主键ID，主键，自增长
+     * @param idEnd
+     */
     public void setIdEnd(Long idEnd){
         this.idEnd = idEnd;
     }
 
     /**
-    * 获取 增加 主键ID，主键，自增长
-    * @return idIncrement
-    */
+     * 获取 增加 主键ID，主键，自增长
+     * @return idIncrement
+     */
     public Long getIdIncrement(){
         return this.idIncrement;
     }
 
     /**
-    * 设置 增加 主键ID，主键，自增长
-    * @param idIncrement
-    */
+     * 设置 增加 主键ID，主键，自增长
+     * @param idIncrement
+     */
     public void setIdIncrement(Long idIncrement){
         this.idIncrement = idIncrement;
     }
 
     /**
-    * 获取 主键ID，主键，自增长
-    * @return idList
-    */
+     * 获取 主键ID，主键，自增长
+     * @return idList
+     */
     public List<Long> getIdList(){
         return this.idList;
     }
 
     /**
-    * 设置 主键ID，主键，自增长
-    * @param idList
-    */
+     * 设置 主键ID，主键，自增长
+     * @param idList
+     */
     public void setIdList(List<Long> idList){
         this.idList = idList;
     }
 
     /**
-    * 获取 主键ID，主键，自增长
-    * @return idNotList
-    */
+     * 获取 主键ID，主键，自增长
+     * @return idNotList
+     */
     public List<Long> getIdNotList(){
         return this.idNotList;
     }
 
     /**
-    * 设置 主键ID，主键，自增长
-    * @param idNotList
-    */
+     * 设置 主键ID，主键，自增长
+     * @param idNotList
+     */
     public void setIdNotList(List<Long> idNotList){
         this.idNotList = idNotList;
     }
 
 
     /**
-    * 获取 开始 站点Id
-    * @return siteIdStart
-    */
+     * 获取 开始 站点Id
+     * @return siteIdStart
+     */
     public Long getSiteIdStart(){
         return this.siteIdStart;
     }
 
     /**
-    * 设置 开始 站点Id
-    * @param siteIdStart
-    */
+     * 设置 开始 站点Id
+     * @param siteIdStart
+     */
     public void setSiteIdStart(Long siteIdStart){
         this.siteIdStart = siteIdStart;
     }
 
     /**
-    * 获取 结束 站点Id
-    * @return $siteIdEnd
-    */
+     * 获取 结束 站点Id
+     * @return $siteIdEnd
+     */
     public Long getSiteIdEnd(){
         return this.siteIdEnd;
     }
 
     /**
-    * 设置 结束 站点Id
-    * @param siteIdEnd
-    */
+     * 设置 结束 站点Id
+     * @param siteIdEnd
+     */
     public void setSiteIdEnd(Long siteIdEnd){
         this.siteIdEnd = siteIdEnd;
     }
 
     /**
-    * 获取 增加 站点Id
-    * @return siteIdIncrement
-    */
+     * 获取 增加 站点Id
+     * @return siteIdIncrement
+     */
     public Long getSiteIdIncrement(){
         return this.siteIdIncrement;
     }
 
     /**
-    * 设置 增加 站点Id
-    * @param siteIdIncrement
-    */
+     * 设置 增加 站点Id
+     * @param siteIdIncrement
+     */
     public void setSiteIdIncrement(Long siteIdIncrement){
         this.siteIdIncrement = siteIdIncrement;
     }
 
     /**
-    * 获取 站点Id
-    * @return siteIdList
-    */
+     * 获取 站点Id
+     * @return siteIdList
+     */
     public List<Long> getSiteIdList(){
         return this.siteIdList;
     }
 
     /**
-    * 设置 站点Id
-    * @param siteIdList
-    */
+     * 设置 站点Id
+     * @param siteIdList
+     */
     public void setSiteIdList(List<Long> siteIdList){
         this.siteIdList = siteIdList;
     }
 
     /**
-    * 获取 站点Id
-    * @return siteIdNotList
-    */
+     * 获取 站点Id
+     * @return siteIdNotList
+     */
     public List<Long> getSiteIdNotList(){
         return this.siteIdNotList;
     }
 
     /**
-    * 设置 站点Id
-    * @param siteIdNotList
-    */
+     * 设置 站点Id
+     * @param siteIdNotList
+     */
     public void setSiteIdNotList(List<Long> siteIdNotList){
         this.siteIdNotList = siteIdNotList;
     }
 
 
     /**
-    * 获取 站点名称
-    * @return siteNameList
-    */
+     * 获取 站点名称
+     * @return siteNameList
+     */
     public List<String> getSiteNameList(){
         return this.siteNameList;
     }
 
     /**
-    * 设置 站点名称
-    * @param siteNameList
-    */
+     * 设置 站点名称
+     * @param siteNameList
+     */
     public void setSiteNameList(List<String> siteNameList){
         this.siteNameList = siteNameList;
     }
 
     /**
-    * 获取 站点名称
-    * @return siteNameNotList
-    */
+     * 获取 站点名称
+     * @return siteNameNotList
+     */
     public List<String> getSiteNameNotList(){
         return this.siteNameNotList;
     }
 
     /**
-    * 设置 站点名称
-    * @param siteNameNotList
-    */
+     * 设置 站点名称
+     * @param siteNameNotList
+     */
     public void setSiteNameNotList(List<String> siteNameNotList){
         this.siteNameNotList = siteNameNotList;
     }
 
     /**
-    * 获取 开始 人员id
-    * @return personIdStart
-    */
+     * 获取 开始 人员id
+     * @return personIdStart
+     */
     public Long getPersonIdStart(){
         return this.personIdStart;
     }
 
     /**
-    * 设置 开始 人员id
-    * @param personIdStart
-    */
+     * 设置 开始 人员id
+     * @param personIdStart
+     */
     public void setPersonIdStart(Long personIdStart){
         this.personIdStart = personIdStart;
     }
 
     /**
-    * 获取 结束 人员id
-    * @return $personIdEnd
-    */
+     * 获取 结束 人员id
+     * @return $personIdEnd
+     */
     public Long getPersonIdEnd(){
         return this.personIdEnd;
     }
 
     /**
-    * 设置 结束 人员id
-    * @param personIdEnd
-    */
+     * 设置 结束 人员id
+     * @param personIdEnd
+     */
     public void setPersonIdEnd(Long personIdEnd){
         this.personIdEnd = personIdEnd;
     }
 
     /**
-    * 获取 增加 人员id
-    * @return personIdIncrement
-    */
+     * 获取 增加 人员id
+     * @return personIdIncrement
+     */
     public Long getPersonIdIncrement(){
         return this.personIdIncrement;
     }
 
     /**
-    * 设置 增加 人员id
-    * @param personIdIncrement
-    */
+     * 设置 增加 人员id
+     * @param personIdIncrement
+     */
     public void setPersonIdIncrement(Long personIdIncrement){
         this.personIdIncrement = personIdIncrement;
     }
 
     /**
-    * 获取 人员id
-    * @return personIdList
-    */
+     * 获取 人员id
+     * @return personIdList
+     */
     public List<Long> getPersonIdList(){
         return this.personIdList;
     }
 
     /**
-    * 设置 人员id
-    * @param personIdList
-    */
+     * 设置 人员id
+     * @param personIdList
+     */
     public void setPersonIdList(List<Long> personIdList){
         this.personIdList = personIdList;
     }
 
     /**
-    * 获取 人员id
-    * @return personIdNotList
-    */
+     * 获取 人员id
+     * @return personIdNotList
+     */
     public List<Long> getPersonIdNotList(){
         return this.personIdNotList;
     }
 
     /**
-    * 设置 人员id
-    * @param personIdNotList
-    */
+     * 设置 人员id
+     * @param personIdNotList
+     */
     public void setPersonIdNotList(List<Long> personIdNotList){
         this.personIdNotList = personIdNotList;
     }
 
 
     /**
-    * 获取 姓名
-    * @return nameList
-    */
+     * 获取 姓名
+     * @return nameList
+     */
     public List<String> getNameList(){
         return this.nameList;
     }
 
     /**
-    * 设置 姓名
-    * @param nameList
-    */
+     * 设置 姓名
+     * @param nameList
+     */
     public void setNameList(List<String> nameList){
         this.nameList = nameList;
     }
 
     /**
-    * 获取 姓名
-    * @return nameNotList
-    */
+     * 获取 姓名
+     * @return nameNotList
+     */
     public List<String> getNameNotList(){
         return this.nameNotList;
     }
 
     /**
-    * 设置 姓名
-    * @param nameNotList
-    */
+     * 设置 姓名
+     * @param nameNotList
+     */
     public void setNameNotList(List<String> nameNotList){
         this.nameNotList = nameNotList;
     }
 
     /**
-    * 获取 监测设备
-    * @return deviceList
-    */
+     * 获取 监测设备
+     * @return deviceList
+     */
     public List<String> getDeviceList(){
         return this.deviceList;
     }
 
     /**
-    * 设置 监测设备
-    * @param deviceList
-    */
+     * 设置 监测设备
+     * @param deviceList
+     */
     public void setDeviceList(List<String> deviceList){
         this.deviceList = deviceList;
     }
 
     /**
-    * 获取 监测设备
-    * @return deviceNotList
-    */
+     * 获取 监测设备
+     * @return deviceNotList
+     */
     public List<String> getDeviceNotList(){
         return this.deviceNotList;
     }
 
     /**
-    * 设置 监测设备
-    * @param deviceNotList
-    */
+     * 设置 监测设备
+     * @param deviceNotList
+     */
     public void setDeviceNotList(List<String> deviceNotList){
         this.deviceNotList = deviceNotList;
     }
 
     /**
-    * 获取 开始 监测时间
-    * @return detectTimeStart
-    */
+     * 获取 开始 监测时间
+     * @return detectTimeStart
+     */
     public String getDetectTimeStart(){
         return this.detectTimeStart;
     }
 
     /**
-    * 设置 开始 监测时间
-    * @param detectTimeStart
-    */
+     * 设置 开始 监测时间
+     * @param detectTimeStart
+     */
     public void setDetectTimeStart(String detectTimeStart){
         this.detectTimeStart = detectTimeStart;
     }
 
     /**
-    * 获取 结束 监测时间
-    * @return detectTimeEnd
-    */
+     * 获取 结束 监测时间
+     * @return detectTimeEnd
+     */
     public String getDetectTimeEnd(){
         return this.detectTimeEnd;
     }
 
     /**
-    * 设置 结束 监测时间
-    * @param detectTimeEnd
-    */
+     * 设置 结束 监测时间
+     * @param detectTimeEnd
+     */
     public void setDetectTimeEnd(String detectTimeEnd){
         this.detectTimeEnd = detectTimeEnd;
     }
 
     /**
-    * 获取 联系方式
-    * @return contactList
-    */
+     * 获取 联系方式
+     * @return contactList
+     */
     public List<String> getContactList(){
         return this.contactList;
     }
 
     /**
-    * 设置 联系方式
-    * @param contactList
-    */
+     * 设置 联系方式
+     * @param contactList
+     */
     public void setContactList(List<String> contactList){
         this.contactList = contactList;
     }
 
     /**
-    * 获取 联系方式
-    * @return contactNotList
-    */
+     * 获取 联系方式
+     * @return contactNotList
+     */
     public List<String> getContactNotList(){
         return this.contactNotList;
     }
 
     /**
-    * 设置 联系方式
-    * @param contactNotList
-    */
+     * 设置 联系方式
+     * @param contactNotList
+     */
     public void setContactNotList(List<String> contactNotList){
         this.contactNotList = contactNotList;
     }
 
     /**
-    * 获取 身份证号码
-    * @return idNumberList
-    */
+     * 获取 身份证号码
+     * @return idNumberList
+     */
     public List<String> getIdNumberList(){
         return this.idNumberList;
     }
 
     /**
-    * 设置 身份证号码
-    * @param idNumberList
-    */
+     * 设置 身份证号码
+     * @param idNumberList
+     */
     public void setIdNumberList(List<String> idNumberList){
         this.idNumberList = idNumberList;
     }
 
     /**
-    * 获取 身份证号码
-    * @return idNumberNotList
-    */
+     * 获取 身份证号码
+     * @return idNumberNotList
+     */
     public List<String> getIdNumberNotList(){
         return this.idNumberNotList;
     }
 
     /**
-    * 设置 身份证号码
-    * @param idNumberNotList
-    */
+     * 设置 身份证号码
+     * @param idNumberNotList
+     */
     public void setIdNumberNotList(List<String> idNumberNotList){
         this.idNumberNotList = idNumberNotList;
     }
 
     /**
-    * 获取 开始 是否预约(0.否，1.是)
-    * @return isBookingStart
-    */
+     * 获取 开始 是否预约(0.否，1.是)
+     * @return isBookingStart
+     */
     public Integer getIsBookingStart(){
         return this.isBookingStart;
     }
 
     /**
-    * 设置 开始 是否预约(0.否，1.是)
-    * @param isBookingStart
-    */
+     * 设置 开始 是否预约(0.否，1.是)
+     * @param isBookingStart
+     */
     public void setIsBookingStart(Integer isBookingStart){
         this.isBookingStart = isBookingStart;
     }
 
     /**
-    * 获取 结束 是否预约(0.否，1.是)
-    * @return $isBookingEnd
-    */
+     * 获取 结束 是否预约(0.否，1.是)
+     * @return $isBookingEnd
+     */
     public Integer getIsBookingEnd(){
         return this.isBookingEnd;
     }
 
     /**
-    * 设置 结束 是否预约(0.否，1.是)
-    * @param isBookingEnd
-    */
+     * 设置 结束 是否预约(0.否，1.是)
+     * @param isBookingEnd
+     */
     public void setIsBookingEnd(Integer isBookingEnd){
         this.isBookingEnd = isBookingEnd;
     }
 
     /**
-    * 获取 增加 是否预约(0.否，1.是)
-    * @return isBookingIncrement
-    */
+     * 获取 增加 是否预约(0.否，1.是)
+     * @return isBookingIncrement
+     */
     public Integer getIsBookingIncrement(){
         return this.isBookingIncrement;
     }
 
     /**
-    * 设置 增加 是否预约(0.否，1.是)
-    * @param isBookingIncrement
-    */
+     * 设置 增加 是否预约(0.否，1.是)
+     * @param isBookingIncrement
+     */
     public void setIsBookingIncrement(Integer isBookingIncrement){
         this.isBookingIncrement = isBookingIncrement;
     }
 
     /**
-    * 获取 是否预约(0.否，1.是)
-    * @return isBookingList
-    */
+     * 获取 是否预约(0.否，1.是)
+     * @return isBookingList
+     */
     public List<Integer> getIsBookingList(){
         return this.isBookingList;
     }
 
     /**
-    * 设置 是否预约(0.否，1.是)
-    * @param isBookingList
-    */
+     * 设置 是否预约(0.否，1.是)
+     * @param isBookingList
+     */
     public void setIsBookingList(List<Integer> isBookingList){
         this.isBookingList = isBookingList;
     }
 
     /**
-    * 获取 是否预约(0.否，1.是)
-    * @return isBookingNotList
-    */
+     * 获取 是否预约(0.否，1.是)
+     * @return isBookingNotList
+     */
     public List<Integer> getIsBookingNotList(){
         return this.isBookingNotList;
     }
 
     /**
-    * 设置 是否预约(0.否，1.是)
-    * @param isBookingNotList
-    */
+     * 设置 是否预约(0.否，1.是)
+     * @param isBookingNotList
+     */
     public void setIsBookingNotList(List<Integer> isBookingNotList){
         this.isBookingNotList = isBookingNotList;
     }
 
 
     /**
-    * 获取 排队编码
-    * @return queueNumList
-    */
+     * 获取 排队编码
+     * @return queueNumList
+     */
     public List<String> getQueueNumList(){
         return this.queueNumList;
     }
 
     /**
-    * 设置 排队编码
-    * @param queueNumList
-    */
+     * 设置 排队编码
+     * @param queueNumList
+     */
     public void setQueueNumList(List<String> queueNumList){
         this.queueNumList = queueNumList;
     }
 
     /**
-    * 获取 排队编码
-    * @return queueNumNotList
-    */
+     * 获取 排队编码
+     * @return queueNumNotList
+     */
     public List<String> getQueueNumNotList(){
         return this.queueNumNotList;
     }
 
     /**
-    * 设置 排队编码
-    * @param queueNumNotList
-    */
+     * 设置 排队编码
+     * @param queueNumNotList
+     */
     public void setQueueNumNotList(List<String> queueNumNotList){
         this.queueNumNotList = queueNumNotList;
     }
 
     /**
-    * 获取 办理位置
-    * @return locationList
-    */
+     * 获取 办理位置
+     * @return locationList
+     */
     public List<String> getLocationList(){
         return this.locationList;
     }
 
     /**
-    * 设置 办理位置
-    * @param locationList
-    */
+     * 设置 办理位置
+     * @param locationList
+     */
     public void setLocationList(List<String> locationList){
         this.locationList = locationList;
     }
 
     /**
-    * 获取 办理位置
-    * @return locationNotList
-    */
+     * 获取 办理位置
+     * @return locationNotList
+     */
     public List<String> getLocationNotList(){
         return this.locationNotList;
     }
 
     /**
-    * 设置 办理位置
-    * @param locationNotList
-    */
+     * 设置 办理位置
+     * @param locationNotList
+     */
     public void setLocationNotList(List<String> locationNotList){
         this.locationNotList = locationNotList;
     }
 
     /**
-    * 获取 识别截图
-    * @return pictureList
-    */
+     * 获取 识别截图
+     * @return pictureList
+     */
     public List<String> getPictureList(){
         return this.pictureList;
     }
 
     /**
-    * 设置 识别截图
-    * @param pictureList
-    */
+     * 设置 识别截图
+     * @param pictureList
+     */
     public void setPictureList(List<String> pictureList){
         this.pictureList = pictureList;
     }
 
     /**
-    * 获取 识别截图
-    * @return pictureNotList
-    */
+     * 获取 识别截图
+     * @return pictureNotList
+     */
     public List<String> getPictureNotList(){
         return this.pictureNotList;
     }
 
     /**
-    * 设置 识别截图
-    * @param pictureNotList
-    */
+     * 设置 识别截图
+     * @param pictureNotList
+     */
     public void setPictureNotList(List<String> pictureNotList){
         this.pictureNotList = pictureNotList;
     }
 
     /**
-    * 获取 开始 创建时间
-    * @return createTimeStart
-    */
+     * 获取 相对图片pic
+     * @return picUriList
+     */
+    public List<String> getPicUriList(){
+        return this.picUriList;
+    }
+
+    /**
+     * 设置 相对图片pic
+     * @param picUriList
+     */
+    public void setPicUriList(List<String> picUriList){
+        this.picUriList = picUriList;
+    }
+
+    /**
+     * 获取 相对图片pic
+     * @return picUriNotList
+     */
+    public List<String> getPicUriNotList(){
+        return this.picUriNotList;
+    }
+
+    /**
+     * 设置 相对图片pic
+     * @param picUriNotList
+     */
+    public void setPicUriNotList(List<String> picUriNotList){
+        this.picUriNotList = picUriNotList;
+    }
+
+    /**
+     * 获取 图片资源唯一标识
+     * @return serverIndexCodeList
+     */
+    public List<String> getServerIndexCodeList(){
+        return this.serverIndexCodeList;
+    }
+
+    /**
+     * 设置 图片资源唯一标识
+     * @param serverIndexCodeList
+     */
+    public void setServerIndexCodeList(List<String> serverIndexCodeList){
+        this.serverIndexCodeList = serverIndexCodeList;
+    }
+
+    /**
+     * 获取 图片资源唯一标识
+     * @return serverIndexCodeNotList
+     */
+    public List<String> getServerIndexCodeNotList(){
+        return this.serverIndexCodeNotList;
+    }
+
+    /**
+     * 设置 图片资源唯一标识
+     * @param serverIndexCodeNotList
+     */
+    public void setServerIndexCodeNotList(List<String> serverIndexCodeNotList){
+        this.serverIndexCodeNotList = serverIndexCodeNotList;
+    }
+
+    /**
+     * 获取 事件id
+     * @return eventIdList
+     */
+    public List<String> getEventIdList(){
+        return this.eventIdList;
+    }
+
+    /**
+     * 设置 事件id
+     * @param eventIdList
+     */
+    public void setEventIdList(List<String> eventIdList){
+        this.eventIdList = eventIdList;
+    }
+
+    /**
+     * 获取 事件id
+     * @return eventIdNotList
+     */
+    public List<String> getEventIdNotList(){
+        return this.eventIdNotList;
+    }
+
+    /**
+     * 设置 事件id
+     * @param eventIdNotList
+     */
+    public void setEventIdNotList(List<String> eventIdNotList){
+        this.eventIdNotList = eventIdNotList;
+    }
+
+    /**
+     * 获取 开始 事件类型
+     * @return eventTypeStart
+     */
+    public Long getEventTypeStart(){
+        return this.eventTypeStart;
+    }
+
+    /**
+     * 设置 开始 事件类型
+     * @param eventTypeStart
+     */
+    public void setEventTypeStart(Long eventTypeStart){
+        this.eventTypeStart = eventTypeStart;
+    }
+
+    /**
+     * 获取 结束 事件类型
+     * @return $eventTypeEnd
+     */
+    public Long getEventTypeEnd(){
+        return this.eventTypeEnd;
+    }
+
+    /**
+     * 设置 结束 事件类型
+     * @param eventTypeEnd
+     */
+    public void setEventTypeEnd(Long eventTypeEnd){
+        this.eventTypeEnd = eventTypeEnd;
+    }
+
+    /**
+     * 获取 增加 事件类型
+     * @return eventTypeIncrement
+     */
+    public Long getEventTypeIncrement(){
+        return this.eventTypeIncrement;
+    }
+
+    /**
+     * 设置 增加 事件类型
+     * @param eventTypeIncrement
+     */
+    public void setEventTypeIncrement(Long eventTypeIncrement){
+        this.eventTypeIncrement = eventTypeIncrement;
+    }
+
+    /**
+     * 获取 事件类型
+     * @return eventTypeList
+     */
+    public List<Long> getEventTypeList(){
+        return this.eventTypeList;
+    }
+
+    /**
+     * 设置 事件类型
+     * @param eventTypeList
+     */
+    public void setEventTypeList(List<Long> eventTypeList){
+        this.eventTypeList = eventTypeList;
+    }
+
+    /**
+     * 获取 事件类型
+     * @return eventTypeNotList
+     */
+    public List<Long> getEventTypeNotList(){
+        return this.eventTypeNotList;
+    }
+
+    /**
+     * 设置 事件类型
+     * @param eventTypeNotList
+     */
+    public void setEventTypeNotList(List<Long> eventTypeNotList){
+        this.eventTypeNotList = eventTypeNotList;
+    }
+
+
+    /**
+     * 获取 开始 创建时间
+     * @return createTimeStart
+     */
     public String getCreateTimeStart(){
         return this.createTimeStart;
     }
 
     /**
-    * 设置 开始 创建时间
-    * @param createTimeStart
-    */
+     * 设置 开始 创建时间
+     * @param createTimeStart
+     */
     public void setCreateTimeStart(String createTimeStart){
         this.createTimeStart = createTimeStart;
     }
 
     /**
-    * 获取 结束 创建时间
-    * @return createTimeEnd
-    */
+     * 获取 结束 创建时间
+     * @return createTimeEnd
+     */
     public String getCreateTimeEnd(){
         return this.createTimeEnd;
     }
 
     /**
-    * 设置 结束 创建时间
-    * @param createTimeEnd
-    */
+     * 设置 结束 创建时间
+     * @param createTimeEnd
+     */
     public void setCreateTimeEnd(String createTimeEnd){
         this.createTimeEnd = createTimeEnd;
     }
 
     /**
-    * 获取 开始 创建人id
-    * @return createUserIdStart
-    */
+     * 获取 开始 创建人id
+     * @return createUserIdStart
+     */
     public Long getCreateUserIdStart(){
         return this.createUserIdStart;
     }
 
     /**
-    * 设置 开始 创建人id
-    * @param createUserIdStart
-    */
+     * 设置 开始 创建人id
+     * @param createUserIdStart
+     */
     public void setCreateUserIdStart(Long createUserIdStart){
         this.createUserIdStart = createUserIdStart;
     }
 
     /**
-    * 获取 结束 创建人id
-    * @return $createUserIdEnd
-    */
+     * 获取 结束 创建人id
+     * @return $createUserIdEnd
+     */
     public Long getCreateUserIdEnd(){
         return this.createUserIdEnd;
     }
 
     /**
-    * 设置 结束 创建人id
-    * @param createUserIdEnd
-    */
+     * 设置 结束 创建人id
+     * @param createUserIdEnd
+     */
     public void setCreateUserIdEnd(Long createUserIdEnd){
         this.createUserIdEnd = createUserIdEnd;
     }
 
     /**
-    * 获取 增加 创建人id
-    * @return createUserIdIncrement
-    */
+     * 获取 增加 创建人id
+     * @return createUserIdIncrement
+     */
     public Long getCreateUserIdIncrement(){
         return this.createUserIdIncrement;
     }
 
     /**
-    * 设置 增加 创建人id
-    * @param createUserIdIncrement
-    */
+     * 设置 增加 创建人id
+     * @param createUserIdIncrement
+     */
     public void setCreateUserIdIncrement(Long createUserIdIncrement){
         this.createUserIdIncrement = createUserIdIncrement;
     }
 
     /**
-    * 获取 创建人id
-    * @return createUserIdList
-    */
+     * 获取 创建人id
+     * @return createUserIdList
+     */
     public List<Long> getCreateUserIdList(){
         return this.createUserIdList;
     }
 
     /**
-    * 设置 创建人id
-    * @param createUserIdList
-    */
+     * 设置 创建人id
+     * @param createUserIdList
+     */
     public void setCreateUserIdList(List<Long> createUserIdList){
         this.createUserIdList = createUserIdList;
     }
 
     /**
-    * 获取 创建人id
-    * @return createUserIdNotList
-    */
+     * 获取 创建人id
+     * @return createUserIdNotList
+     */
     public List<Long> getCreateUserIdNotList(){
         return this.createUserIdNotList;
     }
 
     /**
-    * 设置 创建人id
-    * @param createUserIdNotList
-    */
+     * 设置 创建人id
+     * @param createUserIdNotList
+     */
     public void setCreateUserIdNotList(List<Long> createUserIdNotList){
         this.createUserIdNotList = createUserIdNotList;
     }
 
 
     /**
-    * 获取 开始 更新时间
-    * @return updateTimeStart
-    */
+     * 获取 开始 更新时间
+     * @return updateTimeStart
+     */
     public String getUpdateTimeStart(){
         return this.updateTimeStart;
     }
 
     /**
-    * 设置 开始 更新时间
-    * @param updateTimeStart
-    */
+     * 设置 开始 更新时间
+     * @param updateTimeStart
+     */
     public void setUpdateTimeStart(String updateTimeStart){
         this.updateTimeStart = updateTimeStart;
     }
 
     /**
-    * 获取 结束 更新时间
-    * @return updateTimeEnd
-    */
+     * 获取 结束 更新时间
+     * @return updateTimeEnd
+     */
     public String getUpdateTimeEnd(){
         return this.updateTimeEnd;
     }
 
     /**
-    * 设置 结束 更新时间
-    * @param updateTimeEnd
-    */
+     * 设置 结束 更新时间
+     * @param updateTimeEnd
+     */
     public void setUpdateTimeEnd(String updateTimeEnd){
         this.updateTimeEnd = updateTimeEnd;
     }
 
     /**
-    * 获取 开始 更新人id
-    * @return updateUserIdStart
-    */
+     * 获取 开始 更新人id
+     * @return updateUserIdStart
+     */
     public Long getUpdateUserIdStart(){
         return this.updateUserIdStart;
     }
 
     /**
-    * 设置 开始 更新人id
-    * @param updateUserIdStart
-    */
+     * 设置 开始 更新人id
+     * @param updateUserIdStart
+     */
     public void setUpdateUserIdStart(Long updateUserIdStart){
         this.updateUserIdStart = updateUserIdStart;
     }
 
     /**
-    * 获取 结束 更新人id
-    * @return $updateUserIdEnd
-    */
+     * 获取 结束 更新人id
+     * @return $updateUserIdEnd
+     */
     public Long getUpdateUserIdEnd(){
         return this.updateUserIdEnd;
     }
 
     /**
-    * 设置 结束 更新人id
-    * @param updateUserIdEnd
-    */
+     * 设置 结束 更新人id
+     * @param updateUserIdEnd
+     */
     public void setUpdateUserIdEnd(Long updateUserIdEnd){
         this.updateUserIdEnd = updateUserIdEnd;
     }
 
     /**
-    * 获取 增加 更新人id
-    * @return updateUserIdIncrement
-    */
+     * 获取 增加 更新人id
+     * @return updateUserIdIncrement
+     */
     public Long getUpdateUserIdIncrement(){
         return this.updateUserIdIncrement;
     }
 
     /**
-    * 设置 增加 更新人id
-    * @param updateUserIdIncrement
-    */
+     * 设置 增加 更新人id
+     * @param updateUserIdIncrement
+     */
     public void setUpdateUserIdIncrement(Long updateUserIdIncrement){
         this.updateUserIdIncrement = updateUserIdIncrement;
     }
 
     /**
-    * 获取 更新人id
-    * @return updateUserIdList
-    */
+     * 获取 更新人id
+     * @return updateUserIdList
+     */
     public List<Long> getUpdateUserIdList(){
         return this.updateUserIdList;
     }
 
     /**
-    * 设置 更新人id
-    * @param updateUserIdList
-    */
+     * 设置 更新人id
+     * @param updateUserIdList
+     */
     public void setUpdateUserIdList(List<Long> updateUserIdList){
         this.updateUserIdList = updateUserIdList;
     }
 
     /**
-    * 获取 更新人id
-    * @return updateUserIdNotList
-    */
+     * 获取 更新人id
+     * @return updateUserIdNotList
+     */
     public List<Long> getUpdateUserIdNotList(){
         return this.updateUserIdNotList;
     }
 
     /**
-    * 设置 更新人id
-    * @param updateUserIdNotList
-    */
+     * 设置 更新人id
+     * @param updateUserIdNotList
+     */
     public void setUpdateUserIdNotList(List<Long> updateUserIdNotList){
         this.updateUserIdNotList = updateUserIdNotList;
     }
 
 
     /**
-    * 设置  主键ID，主键，自增长
-    * @param id
-    */
+     * 设置  主键ID，主键，自增长
+     * @param id
+     */
     public RealtimeDataflowQuery id(Long id){
-	    setId(id);
-		return this;
-    }
-	
-	 /**
-    * 设置 开始 主键ID，主键，自增长
-    * @param idStart
-    */
+        setId(id);
+        return this;
+    }
+
+    /**
+     * 设置 开始 主键ID，主键，自增长
+     * @param idStart
+     */
     public RealtimeDataflowQuery idStart(Long idStart){
-		this.idStart = idStart;
-		return this;
+        this.idStart = idStart;
+        return this;
     }
 
     /**
-    * 设置 结束 主键ID，主键，自增长
-    * @param idEnd
-    */
+     * 设置 结束 主键ID，主键，自增长
+     * @param idEnd
+     */
     public RealtimeDataflowQuery idEnd(Long idEnd){
-		this.idEnd = idEnd;
-		return this;
+        this.idEnd = idEnd;
+        return this;
     }
 
     /**
-    * 设置 增加 主键ID，主键，自增长
-    * @param idIncrement
-    */
+     * 设置 增加 主键ID，主键，自增长
+     * @param idIncrement
+     */
     public RealtimeDataflowQuery idIncrement(Long idIncrement){
-		this.idIncrement = idIncrement;
-		return this;
+        this.idIncrement = idIncrement;
+        return this;
     }
 
     /**
-    * 设置 主键ID，主键，自增长
-    * @param idList
-    */
+     * 设置 主键ID，主键，自增长
+     * @param idList
+     */
     public RealtimeDataflowQuery idList(List<Long> idList){
         this.idList = idList;
-		return this;
-        }
-
-        /**
-        * 设置 主键ID，主键，自增长
-        * @param idNotList
-        */
-        public RealtimeDataflowQuery idNotList(List<Long> idNotList){
+        return this;
+    }
+
+    /**
+     * 设置 主键ID，主键，自增长
+     * @param idNotList
+     */
+    public RealtimeDataflowQuery idNotList(List<Long> idNotList){
         this.idNotList = idNotList;
         return this;
-        }
+    }
 
     /**
-    * 设置  站点Id
-    * @param siteId
-    */
+     * 设置  站点Id
+     * @param siteId
+     */
     public RealtimeDataflowQuery siteId(Long siteId){
-	    setSiteId(siteId);
-		return this;
-    }
-	
-	 /**
-    * 设置 开始 站点Id
-    * @param siteIdStart
-    */
+        setSiteId(siteId);
+        return this;
+    }
+
+    /**
+     * 设置 开始 站点Id
+     * @param siteIdStart
+     */
     public RealtimeDataflowQuery siteIdStart(Long siteIdStart){
-		this.siteIdStart = siteIdStart;
-		return this;
+        this.siteIdStart = siteIdStart;
+        return this;
     }
 
     /**
-    * 设置 结束 站点Id
-    * @param siteIdEnd
-    */
+     * 设置 结束 站点Id
+     * @param siteIdEnd
+     */
     public RealtimeDataflowQuery siteIdEnd(Long siteIdEnd){
-		this.siteIdEnd = siteIdEnd;
-		return this;
+        this.siteIdEnd = siteIdEnd;
+        return this;
     }
 
     /**
-    * 设置 增加 站点Id
-    * @param siteIdIncrement
-    */
+     * 设置 增加 站点Id
+     * @param siteIdIncrement
+     */
     public RealtimeDataflowQuery siteIdIncrement(Long siteIdIncrement){
-		this.siteIdIncrement = siteIdIncrement;
-		return this;
+        this.siteIdIncrement = siteIdIncrement;
+        return this;
     }
 
     /**
-    * 设置 站点Id
-    * @param siteIdList
-    */
+     * 设置 站点Id
+     * @param siteIdList
+     */
     public RealtimeDataflowQuery siteIdList(List<Long> siteIdList){
         this.siteIdList = siteIdList;
-		return this;
-        }
-
-        /**
-        * 设置 站点Id
-        * @param siteIdNotList
-        */
-        public RealtimeDataflowQuery siteIdNotList(List<Long> siteIdNotList){
+        return this;
+    }
+
+    /**
+     * 设置 站点Id
+     * @param siteIdNotList
+     */
+    public RealtimeDataflowQuery siteIdNotList(List<Long> siteIdNotList){
         this.siteIdNotList = siteIdNotList;
         return this;
-        }
+    }
 
 
-	/**
-    * 设置 站点名称
-    * @param siteName
-    */
+    /**
+     * 设置 站点名称
+     * @param siteName
+     */
     public RealtimeDataflowQuery siteName(String siteName){
         setSiteName(siteName);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 站点名称
-    * @param siteNameList
-    */
+     * 设置 站点名称
+     * @param siteNameList
+     */
     public RealtimeDataflowQuery siteNameList(List<String> siteNameList){
         this.siteNameList = siteNameList;
-		return this;
+        return this;
     }
 
     /**
-    * 设置  人员id
-    * @param personId
-    */
+     * 设置  人员id
+     * @param personId
+     */
     public RealtimeDataflowQuery personId(Long personId){
-	    setPersonId(personId);
-		return this;
-    }
-	
-	 /**
-    * 设置 开始 人员id
-    * @param personIdStart
-    */
+        setPersonId(personId);
+        return this;
+    }
+
+    /**
+     * 设置 开始 人员id
+     * @param personIdStart
+     */
     public RealtimeDataflowQuery personIdStart(Long personIdStart){
-		this.personIdStart = personIdStart;
-		return this;
+        this.personIdStart = personIdStart;
+        return this;
     }
 
     /**
-    * 设置 结束 人员id
-    * @param personIdEnd
-    */
+     * 设置 结束 人员id
+     * @param personIdEnd
+     */
     public RealtimeDataflowQuery personIdEnd(Long personIdEnd){
-		this.personIdEnd = personIdEnd;
-		return this;
+        this.personIdEnd = personIdEnd;
+        return this;
     }
 
     /**
-    * 设置 增加 人员id
-    * @param personIdIncrement
-    */
+     * 设置 增加 人员id
+     * @param personIdIncrement
+     */
     public RealtimeDataflowQuery personIdIncrement(Long personIdIncrement){
-		this.personIdIncrement = personIdIncrement;
-		return this;
+        this.personIdIncrement = personIdIncrement;
+        return this;
     }
 
     /**
-    * 设置 人员id
-    * @param personIdList
-    */
+     * 设置 人员id
+     * @param personIdList
+     */
     public RealtimeDataflowQuery personIdList(List<Long> personIdList){
         this.personIdList = personIdList;
-		return this;
-        }
-
-        /**
-        * 设置 人员id
-        * @param personIdNotList
-        */
-        public RealtimeDataflowQuery personIdNotList(List<Long> personIdNotList){
+        return this;
+    }
+
+    /**
+     * 设置 人员id
+     * @param personIdNotList
+     */
+    public RealtimeDataflowQuery personIdNotList(List<Long> personIdNotList){
         this.personIdNotList = personIdNotList;
         return this;
-        }
+    }
 
 
-	/**
-    * 设置 姓名
-    * @param name
-    */
+    /**
+     * 设置 姓名
+     * @param name
+     */
     public RealtimeDataflowQuery name(String name){
         setName(name);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 姓名
-    * @param nameList
-    */
+     * 设置 姓名
+     * @param nameList
+     */
     public RealtimeDataflowQuery nameList(List<String> nameList){
         this.nameList = nameList;
-		return this;
+        return this;
     }
 
 
-	/**
-    * 设置 监测设备
-    * @param device
-    */
+    /**
+     * 设置 监测设备
+     * @param device
+     */
     public RealtimeDataflowQuery device(String device){
         setDevice(device);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 监测设备
-    * @param deviceList
-    */
+     * 设置 监测设备
+     * @param deviceList
+     */
     public RealtimeDataflowQuery deviceList(List<String> deviceList){
         this.deviceList = deviceList;
-		return this;
+        return this;
     }
 
 
 
-	/**
-    * 设置 联系方式
-    * @param contact
-    */
+    /**
+     * 设置 联系方式
+     * @param contact
+     */
     public RealtimeDataflowQuery contact(String contact){
         setContact(contact);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 联系方式
-    * @param contactList
-    */
+     * 设置 联系方式
+     * @param contactList
+     */
     public RealtimeDataflowQuery contactList(List<String> contactList){
         this.contactList = contactList;
-		return this;
+        return this;
     }
 
 
-	/**
-    * 设置 身份证号码
-    * @param idNumber
-    */
+    /**
+     * 设置 身份证号码
+     * @param idNumber
+     */
     public RealtimeDataflowQuery idNumber(String idNumber){
         setIdNumber(idNumber);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 身份证号码
-    * @param idNumberList
-    */
+     * 设置 身份证号码
+     * @param idNumberList
+     */
     public RealtimeDataflowQuery idNumberList(List<String> idNumberList){
         this.idNumberList = idNumberList;
-		return this;
+        return this;
     }
 
     /**
-    * 设置  是否预约(0.否，1.是)
-    * @param isBooking
-    */
+     * 设置  是否预约(0.否，1.是)
+     * @param isBooking
+     */
     public RealtimeDataflowQuery isBooking(Integer isBooking){
-	    setIsBooking(isBooking);
-		return this;
-    }
-	
-	 /**
-    * 设置 开始 是否预约(0.否，1.是)
-    * @param isBookingStart
-    */
+        setIsBooking(isBooking);
+        return this;
+    }
+
+    /**
+     * 设置 开始 是否预约(0.否，1.是)
+     * @param isBookingStart
+     */
     public RealtimeDataflowQuery isBookingStart(Integer isBookingStart){
-		this.isBookingStart = isBookingStart;
-		return this;
+        this.isBookingStart = isBookingStart;
+        return this;
     }
 
     /**
-    * 设置 结束 是否预约(0.否，1.是)
-    * @param isBookingEnd
-    */
+     * 设置 结束 是否预约(0.否，1.是)
+     * @param isBookingEnd
+     */
     public RealtimeDataflowQuery isBookingEnd(Integer isBookingEnd){
-		this.isBookingEnd = isBookingEnd;
-		return this;
+        this.isBookingEnd = isBookingEnd;
+        return this;
     }
 
     /**
-    * 设置 增加 是否预约(0.否，1.是)
-    * @param isBookingIncrement
-    */
+     * 设置 增加 是否预约(0.否，1.是)
+     * @param isBookingIncrement
+     */
     public RealtimeDataflowQuery isBookingIncrement(Integer isBookingIncrement){
-		this.isBookingIncrement = isBookingIncrement;
-		return this;
+        this.isBookingIncrement = isBookingIncrement;
+        return this;
     }
 
     /**
-    * 设置 是否预约(0.否，1.是)
-    * @param isBookingList
-    */
+     * 设置 是否预约(0.否，1.是)
+     * @param isBookingList
+     */
     public RealtimeDataflowQuery isBookingList(List<Integer> isBookingList){
         this.isBookingList = isBookingList;
-		return this;
-        }
-
-        /**
-        * 设置 是否预约(0.否，1.是)
-        * @param isBookingNotList
-        */
-        public RealtimeDataflowQuery isBookingNotList(List<Integer> isBookingNotList){
+        return this;
+    }
+
+    /**
+     * 设置 是否预约(0.否，1.是)
+     * @param isBookingNotList
+     */
+    public RealtimeDataflowQuery isBookingNotList(List<Integer> isBookingNotList){
         this.isBookingNotList = isBookingNotList;
         return this;
-        }
+    }
 
 
-	/**
-    * 设置 排队编码
-    * @param queueNum
-    */
+    /**
+     * 设置 排队编码
+     * @param queueNum
+     */
     public RealtimeDataflowQuery queueNum(String queueNum){
         setQueueNum(queueNum);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 排队编码
-    * @param queueNumList
-    */
+     * 设置 排队编码
+     * @param queueNumList
+     */
     public RealtimeDataflowQuery queueNumList(List<String> queueNumList){
         this.queueNumList = queueNumList;
-		return this;
+        return this;
     }
 
 
-	/**
-    * 设置 办理位置
-    * @param location
-    */
+    /**
+     * 设置 办理位置
+     * @param location
+     */
     public RealtimeDataflowQuery location(String location){
         setLocation(location);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 办理位置
-    * @param locationList
-    */
+     * 设置 办理位置
+     * @param locationList
+     */
     public RealtimeDataflowQuery locationList(List<String> locationList){
         this.locationList = locationList;
-		return this;
+        return this;
     }
 
 
-	/**
-    * 设置 识别截图
-    * @param picture
-    */
+    /**
+     * 设置 识别截图
+     * @param picture
+     */
     public RealtimeDataflowQuery picture(String picture){
         setPicture(picture);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 识别截图
-    * @param pictureList
-    */
+     * 设置 识别截图
+     * @param pictureList
+     */
     public RealtimeDataflowQuery pictureList(List<String> pictureList){
         this.pictureList = pictureList;
-		return this;
+        return this;
+    }
+
+
+    /**
+     * 设置 相对图片pic
+     * @param picUri
+     */
+    public RealtimeDataflowQuery picUri(String picUri){
+        setPicUri(picUri);
+        return this;
+    }
+
+    /**
+     * 设置 相对图片pic
+     * @param picUriList
+     */
+    public RealtimeDataflowQuery picUriList(List<String> picUriList){
+        this.picUriList = picUriList;
+        return this;
+    }
+
+
+    /**
+     * 设置 图片资源唯一标识
+     * @param serverIndexCode
+     */
+    public RealtimeDataflowQuery serverIndexCode(String serverIndexCode){
+        setServerIndexCode(serverIndexCode);
+        return this;
+    }
+
+    /**
+     * 设置 图片资源唯一标识
+     * @param serverIndexCodeList
+     */
+    public RealtimeDataflowQuery serverIndexCodeList(List<String> serverIndexCodeList){
+        this.serverIndexCodeList = serverIndexCodeList;
+        return this;
+    }
+
+
+    /**
+     * 设置 事件id
+     * @param eventId
+     */
+    public RealtimeDataflowQuery eventId(String eventId){
+        setEventId(eventId);
+        return this;
+    }
+
+    /**
+     * 设置 事件id
+     * @param eventIdList
+     */
+    public RealtimeDataflowQuery eventIdList(List<String> eventIdList){
+        this.eventIdList = eventIdList;
+        return this;
+    }
+
+    /**
+     * 设置  事件类型
+     * @param eventType
+     */
+    public RealtimeDataflowQuery eventType(Long eventType){
+        setEventType(eventType);
+        return this;
+    }
+
+    /**
+     * 设置 开始 事件类型
+     * @param eventTypeStart
+     */
+    public RealtimeDataflowQuery eventTypeStart(Long eventTypeStart){
+        this.eventTypeStart = eventTypeStart;
+        return this;
+    }
+
+    /**
+     * 设置 结束 事件类型
+     * @param eventTypeEnd
+     */
+    public RealtimeDataflowQuery eventTypeEnd(Long eventTypeEnd){
+        this.eventTypeEnd = eventTypeEnd;
+        return this;
+    }
+
+    /**
+     * 设置 增加 事件类型
+     * @param eventTypeIncrement
+     */
+    public RealtimeDataflowQuery eventTypeIncrement(Long eventTypeIncrement){
+        this.eventTypeIncrement = eventTypeIncrement;
+        return this;
+    }
+
+    /**
+     * 设置 事件类型
+     * @param eventTypeList
+     */
+    public RealtimeDataflowQuery eventTypeList(List<Long> eventTypeList){
+        this.eventTypeList = eventTypeList;
+        return this;
+    }
+
+    /**
+     * 设置 事件类型
+     * @param eventTypeNotList
+     */
+    public RealtimeDataflowQuery eventTypeNotList(List<Long> eventTypeNotList){
+        this.eventTypeNotList = eventTypeNotList;
+        return this;
     }
 
 
     /**
-    * 设置  创建人id
-    * @param createUserId
-    */
+     * 设置  创建人id
+     * @param createUserId
+     */
     public RealtimeDataflowQuery createUserId(Long createUserId){
-	    setCreateUserId(createUserId);
-		return this;
-    }
-	
-	 /**
-    * 设置 开始 创建人id
-    * @param createUserIdStart
-    */
+        setCreateUserId(createUserId);
+        return this;
+    }
+
+    /**
+     * 设置 开始 创建人id
+     * @param createUserIdStart
+     */
     public RealtimeDataflowQuery createUserIdStart(Long createUserIdStart){
-		this.createUserIdStart = createUserIdStart;
-		return this;
+        this.createUserIdStart = createUserIdStart;
+        return this;
     }
 
     /**
-    * 设置 结束 创建人id
-    * @param createUserIdEnd
-    */
+     * 设置 结束 创建人id
+     * @param createUserIdEnd
+     */
     public RealtimeDataflowQuery createUserIdEnd(Long createUserIdEnd){
-		this.createUserIdEnd = createUserIdEnd;
-		return this;
+        this.createUserIdEnd = createUserIdEnd;
+        return this;
     }
 
     /**
-    * 设置 增加 创建人id
-    * @param createUserIdIncrement
-    */
+     * 设置 增加 创建人id
+     * @param createUserIdIncrement
+     */
     public RealtimeDataflowQuery createUserIdIncrement(Long createUserIdIncrement){
-		this.createUserIdIncrement = createUserIdIncrement;
-		return this;
+        this.createUserIdIncrement = createUserIdIncrement;
+        return this;
     }
 
     /**
-    * 设置 创建人id
-    * @param createUserIdList
-    */
+     * 设置 创建人id
+     * @param createUserIdList
+     */
     public RealtimeDataflowQuery createUserIdList(List<Long> createUserIdList){
         this.createUserIdList = createUserIdList;
-		return this;
-        }
-
-        /**
-        * 设置 创建人id
-        * @param createUserIdNotList
-        */
-        public RealtimeDataflowQuery createUserIdNotList(List<Long> createUserIdNotList){
+        return this;
+    }
+
+    /**
+     * 设置 创建人id
+     * @param createUserIdNotList
+     */
+    public RealtimeDataflowQuery createUserIdNotList(List<Long> createUserIdNotList){
         this.createUserIdNotList = createUserIdNotList;
         return this;
-        }
+    }
 
 
     /**
-    * 设置  更新人id
-    * @param updateUserId
-    */
+     * 设置  更新人id
+     * @param updateUserId
+     */
     public RealtimeDataflowQuery updateUserId(Long updateUserId){
-	    setUpdateUserId(updateUserId);
-		return this;
-    }
-	
-	 /**
-    * 设置 开始 更新人id
-    * @param updateUserIdStart
-    */
+        setUpdateUserId(updateUserId);
+        return this;
+    }
+
+    /**
+     * 设置 开始 更新人id
+     * @param updateUserIdStart
+     */
     public RealtimeDataflowQuery updateUserIdStart(Long updateUserIdStart){
-		this.updateUserIdStart = updateUserIdStart;
-		return this;
+        this.updateUserIdStart = updateUserIdStart;
+        return this;
     }
 
     /**
-    * 设置 结束 更新人id
-    * @param updateUserIdEnd
-    */
+     * 设置 结束 更新人id
+     * @param updateUserIdEnd
+     */
     public RealtimeDataflowQuery updateUserIdEnd(Long updateUserIdEnd){
-		this.updateUserIdEnd = updateUserIdEnd;
-		return this;
+        this.updateUserIdEnd = updateUserIdEnd;
+        return this;
     }
 
     /**
-    * 设置 增加 更新人id
-    * @param updateUserIdIncrement
-    */
+     * 设置 增加 更新人id
+     * @param updateUserIdIncrement
+     */
     public RealtimeDataflowQuery updateUserIdIncrement(Long updateUserIdIncrement){
-		this.updateUserIdIncrement = updateUserIdIncrement;
-		return this;
+        this.updateUserIdIncrement = updateUserIdIncrement;
+        return this;
     }
 
     /**
-    * 设置 更新人id
-    * @param updateUserIdList
-    */
+     * 设置 更新人id
+     * @param updateUserIdList
+     */
     public RealtimeDataflowQuery updateUserIdList(List<Long> updateUserIdList){
         this.updateUserIdList = updateUserIdList;
-		return this;
-        }
-
-        /**
-        * 设置 更新人id
-        * @param updateUserIdNotList
-        */
-        public RealtimeDataflowQuery updateUserIdNotList(List<Long> updateUserIdNotList){
+        return this;
+    }
+
+    /**
+     * 设置 更新人id
+     * @param updateUserIdNotList
+     */
+    public RealtimeDataflowQuery 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
-    */
+     * 获取 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
+     * @return orConditionList
+     */
     public List<RealtimeDataflowQuery> getOrConditionList(){
-    return this.orConditionList;
+        return this.orConditionList;
     }
 
     /**
-    * 设置 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
-    * @param orConditionList
-    */
+     * 设置 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
+     * @param orConditionList
+     */
     public void setOrConditionList(List<RealtimeDataflowQuery> orConditionList){
         this.orConditionList = orConditionList;
     }
 
     /**
-    * 获取 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
-    * @return andConditionList
-    */
+     * 获取 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
+     * @return andConditionList
+     */
     public List<RealtimeDataflowQuery> getAndConditionList(){
         return this.andConditionList;
     }
 
     /**
-    * 设置 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
-    * @param andConditionList
-    */
+     * 设置 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
+     * @param andConditionList
+     */
     public void setAndConditionList(List<RealtimeDataflowQuery> andConditionList){
         this.andConditionList = andConditionList;
     }

refined-manager/src/main/resources/sqlmap/module/realtime/RealtimeDataflowMapper.xml

 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
-"mybatis-3-mapper.dtd">
+        "mybatis-3-mapper.dtd">
 <mapper namespace="com.mortals.xhx.module.realtime.dao.ibatis.RealtimeDataflowDaoImpl">
 
     <!-- 字段和属性映射 -->
     <resultMap type="RealtimeDataflowEntity" id="RealtimeDataflowEntity-Map">
-            <id  property="id" column="id" />
-            <result property="siteId" column="siteId" />
-            <result property="siteName" column="siteName" />
-            <result property="personId" column="personId" />
-            <result property="name" column="name" />
-            <result property="device" column="device" />
-            <result property="detectTime" column="detectTime" />
-            <result property="contact" column="contact" />
-            <result property="idNumber" column="idNumber" />
-            <result property="isBooking" column="isBooking" />
-            <result property="queueNum" column="queueNum" />
-            <result property="location" column="location" />
-            <result property="picture" column="picture" />
-            <result property="createTime" column="createTime" />
-            <result property="createUserId" column="createUserId" />
-            <result property="updateTime" column="updateTime" />
-            <result property="updateUserId" column="updateUserId" />
-            
+        <id  property="id" column="id" />
+        <result property="siteId" column="siteId" />
+        <result property="siteName" column="siteName" />
+        <result property="personId" column="personId" />
+        <result property="name" column="name" />
+        <result property="device" column="device" />
+        <result property="detectTime" column="detectTime" />
+        <result property="contact" column="contact" />
+        <result property="idNumber" column="idNumber" />
+        <result property="isBooking" column="isBooking" />
+        <result property="queueNum" column="queueNum" />
+        <result property="location" column="location" />
+        <result property="picture" column="picture" />
+        <result property="picUri" column="picUri" />
+        <result property="serverIndexCode" column="serverIndexCode" />
+        <result property="eventId" column="eventId" />
+        <result property="eventType" column="eventType" />
+        <result property="createTime" column="createTime" />
+        <result property="createUserId" column="createUserId" />
+        <result property="updateTime" column="updateTime" />
+        <result property="updateUserId" column="updateUserId" />
+
     </resultMap>
 
 
     <!-- 表所有列 -->
     <sql id="_columns">
         <trim suffixOverrides="," suffix="">
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('id') or colPickMode == 1 and data.containsKey('id')))">
-                    a.id,
-                </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('siteId') or colPickMode == 1 and data.containsKey('siteId')))">
-                    a.siteId,
-                </if>
-                <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('personId') or colPickMode == 1 and data.containsKey('personId')))">
-                    a.personId,
-                </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('name') or colPickMode == 1 and data.containsKey('name')))">
-                    a.name,
-                </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('device') or colPickMode == 1 and data.containsKey('device')))">
-                    a.device,
-                </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('detectTime') or colPickMode == 1 and data.containsKey('detectTime')))">
-                    a.detectTime,
-                </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('contact') or colPickMode == 1 and data.containsKey('contact')))">
-                    a.contact,
-                </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('idNumber') or colPickMode == 1 and data.containsKey('idNumber')))">
-                    a.idNumber,
-                </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('isBooking') or colPickMode == 1 and data.containsKey('isBooking')))">
-                    a.isBooking,
-                </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('queueNum') or colPickMode == 1 and data.containsKey('queueNum')))">
-                    a.queueNum,
-                </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('location') or colPickMode == 1 and data.containsKey('location')))">
-                    a.location,
-                </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('picture') or colPickMode == 1 and data.containsKey('picture')))">
-                    a.picture,
-                </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createTime') or colPickMode == 1 and data.containsKey('createTime')))">
-                    a.createTime,
-                </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createUserId') or colPickMode == 1 and data.containsKey('createUserId')))">
-                    a.createUserId,
-                </if>
-                <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('updateUserId') or colPickMode == 1 and data.containsKey('updateUserId')))">
-                    a.updateUserId,
-                </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('id') or colPickMode == 1 and data.containsKey('id')))">
+                a.id,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('siteId') or colPickMode == 1 and data.containsKey('siteId')))">
+                a.siteId,
+            </if>
+            <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('personId') or colPickMode == 1 and data.containsKey('personId')))">
+                a.personId,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('name') or colPickMode == 1 and data.containsKey('name')))">
+                a.name,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('device') or colPickMode == 1 and data.containsKey('device')))">
+                a.device,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('detectTime') or colPickMode == 1 and data.containsKey('detectTime')))">
+                a.detectTime,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('contact') or colPickMode == 1 and data.containsKey('contact')))">
+                a.contact,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('idNumber') or colPickMode == 1 and data.containsKey('idNumber')))">
+                a.idNumber,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('isBooking') or colPickMode == 1 and data.containsKey('isBooking')))">
+                a.isBooking,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('queueNum') or colPickMode == 1 and data.containsKey('queueNum')))">
+                a.queueNum,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('location') or colPickMode == 1 and data.containsKey('location')))">
+                a.location,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('picture') or colPickMode == 1 and data.containsKey('picture')))">
+                a.picture,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('picUri') or colPickMode == 1 and data.containsKey('picUri')))">
+                a.picUri,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('serverIndexCode') or colPickMode == 1 and data.containsKey('serverIndexCode')))">
+                a.serverIndexCode,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('eventId') or colPickMode == 1 and data.containsKey('eventId')))">
+                a.eventId,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('eventType') or colPickMode == 1 and data.containsKey('eventType')))">
+                a.eventType,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createTime') or colPickMode == 1 and data.containsKey('createTime')))">
+                a.createTime,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createUserId') or colPickMode == 1 and data.containsKey('createUserId')))">
+                a.createUserId,
+            </if>
+            <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('updateUserId') or colPickMode == 1 and data.containsKey('updateUserId')))">
+                a.updateUserId,
+            </if>
         </trim>
     </sql>
     <!-- 新增 区分主键自增加还是业务插入 -->
     <insert id="insert" parameterType="RealtimeDataflowEntity"  useGeneratedKeys="true" keyProperty="id">
         insert into mortals_xhx_realtime_dataflow
-        (siteId,siteName,personId,name,device,detectTime,contact,idNumber,isBooking,queueNum,location,picture,createTime,createUserId,updateTime,updateUserId)
+        (siteId,siteName,personId,name,device,detectTime,contact,idNumber,isBooking,queueNum,location,picture,picUri,serverIndexCode,eventId,eventType,createTime,createUserId,updateTime,updateUserId)
         VALUES
-        (#{siteId},#{siteName},#{personId},#{name},#{device},#{detectTime},#{contact},#{idNumber},#{isBooking},#{queueNum},#{location},#{picture},#{createTime},#{createUserId},#{updateTime},#{updateUserId})
+        (#{siteId},#{siteName},#{personId},#{name},#{device},#{detectTime},#{contact},#{idNumber},#{isBooking},#{queueNum},#{location},#{picture},#{picUri},#{serverIndexCode},#{eventId},#{eventType},#{createTime},#{createUserId},#{updateTime},#{updateUserId})
     </insert>
 
     <!-- 批量新增 -->
     <insert id="insertBatch" parameterType="paramDto">
         insert into mortals_xhx_realtime_dataflow
-        (siteId,siteName,personId,name,device,detectTime,contact,idNumber,isBooking,queueNum,location,picture,createTime,createUserId,updateTime,updateUserId)
+        (siteId,siteName,personId,name,device,detectTime,contact,idNumber,isBooking,queueNum,location,picture,picUri,serverIndexCode,eventId,eventType,createTime,createUserId,updateTime,updateUserId)
         VALUES
         <foreach collection="data.dataList" item="item" index="index" separator="," >
-            (#{item.siteId},#{item.siteName},#{item.personId},#{item.name},#{item.device},#{item.detectTime},#{item.contact},#{item.idNumber},#{item.isBooking},#{item.queueNum},#{item.location},#{item.picture},#{item.createTime},#{item.createUserId},#{item.updateTime},#{item.updateUserId})
+            (#{item.siteId},#{item.siteName},#{item.personId},#{item.name},#{item.device},#{item.detectTime},#{item.contact},#{item.idNumber},#{item.isBooking},#{item.queueNum},#{item.location},#{item.picture},#{item.picUri},#{item.serverIndexCode},#{item.eventId},#{item.eventType},#{item.createTime},#{item.createUserId},#{item.updateTime},#{item.updateUserId})
         </foreach>
     </insert>
 
@@ -151,6 +167,21 @@
             <if test="(colPickMode==0 and data.containsKey('picture')) or (colPickMode==1 and !data.containsKey('picture'))">
                 a.picture=#{data.picture},
             </if>
+            <if test="(colPickMode==0 and data.containsKey('picUri')) or (colPickMode==1 and !data.containsKey('picUri'))">
+                a.picUri=#{data.picUri},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('serverIndexCode')) or (colPickMode==1 and !data.containsKey('serverIndexCode'))">
+                a.serverIndexCode=#{data.serverIndexCode},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('eventId')) or (colPickMode==1 and !data.containsKey('eventId'))">
+                a.eventId=#{data.eventId},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('eventType')) or (colPickMode==1 and !data.containsKey('eventType'))">
+                a.eventType=#{data.eventType},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('eventTypeIncrement')) or (colPickMode==1 and !data.containsKey('eventTypeIncrement'))">
+                a.eventType=ifnull(a.eventType,0) + #{data.eventTypeIncrement},
+            </if>
             <if test="(colPickMode==0 and data.containsKey('createTime')) or (colPickMode==1 and !data.containsKey('createTime'))">
                 a.createTime=#{data.createTime},
             </if>
@@ -181,143 +212,176 @@
     <update id="updateBatch" parameterType="paramDto">
         update mortals_xhx_realtime_dataflow as a
         <trim prefix="set" suffixOverrides=",">
-                        <trim prefix="siteId=(case" suffix="ELSE siteId end),">
-                            <foreach collection="data.dataList" item="item" index="index" separator="" >
-                                <choose>
-                                    <when test="(colPickMode==0 and item.containsKey('siteId')) or (colPickMode==1 and !item.containsKey('siteId'))">
-                                        when a.id=#{item.id} then #{item.siteId}
-                                    </when>
-                                    <when test="(colPickMode==0 and item.containsKey('siteIdIncrement')) or (colPickMode==1 and !item.containsKey('siteIdIncrement'))">
-                                        when a.id=#{item.id} then ifnull(a.siteId,0) + #{item.siteIdIncrement}
-                                    </when>
-                                </choose>
-                            </foreach>
-                        </trim>
-                <trim prefix="siteName=(case" suffix="ELSE siteName end),">
-                    <foreach collection="data.dataList" item="item" index="index" separator="" >
-                        <if test="(colPickMode==0 and item.containsKey('siteName')) or (colPickMode==1 and !item.containsKey('siteName'))">
-                            when a.id=#{item.id} then #{item.siteName}
-                        </if>
-                    </foreach>
-                </trim>
-                        <trim prefix="personId=(case" suffix="ELSE personId end),">
-                            <foreach collection="data.dataList" item="item" index="index" separator="" >
-                                <choose>
-                                    <when test="(colPickMode==0 and item.containsKey('personId')) or (colPickMode==1 and !item.containsKey('personId'))">
-                                        when a.id=#{item.id} then #{item.personId}
-                                    </when>
-                                    <when test="(colPickMode==0 and item.containsKey('personIdIncrement')) or (colPickMode==1 and !item.containsKey('personIdIncrement'))">
-                                        when a.id=#{item.id} then ifnull(a.personId,0) + #{item.personIdIncrement}
-                                    </when>
-                                </choose>
-                            </foreach>
-                        </trim>
-                <trim prefix="name=(case" suffix="ELSE name end),">
-                    <foreach collection="data.dataList" item="item" index="index" separator="" >
-                        <if test="(colPickMode==0 and item.containsKey('name')) or (colPickMode==1 and !item.containsKey('name'))">
-                            when a.id=#{item.id} then #{item.name}
-                        </if>
-                    </foreach>
-                </trim>
-                <trim prefix="device=(case" suffix="ELSE device end),">
-                    <foreach collection="data.dataList" item="item" index="index" separator="" >
-                        <if test="(colPickMode==0 and item.containsKey('device')) or (colPickMode==1 and !item.containsKey('device'))">
-                            when a.id=#{item.id} then #{item.device}
-                        </if>
-                    </foreach>
-                </trim>
-                <trim prefix="detectTime=(case" suffix="ELSE detectTime end),">
-                    <foreach collection="data.dataList" item="item" index="index" separator="" >
-                        <if test="(colPickMode==0 and item.containsKey('detectTime')) or (colPickMode==1 and !item.containsKey('detectTime'))">
-                            when a.id=#{item.id} then #{item.detectTime}
-                        </if>
-                    </foreach>
-                </trim>
-                <trim prefix="contact=(case" suffix="ELSE contact end),">
-                    <foreach collection="data.dataList" item="item" index="index" separator="" >
-                        <if test="(colPickMode==0 and item.containsKey('contact')) or (colPickMode==1 and !item.containsKey('contact'))">
-                            when a.id=#{item.id} then #{item.contact}
-                        </if>
-                    </foreach>
-                </trim>
-                <trim prefix="idNumber=(case" suffix="ELSE idNumber end),">
-                    <foreach collection="data.dataList" item="item" index="index" separator="" >
-                        <if test="(colPickMode==0 and item.containsKey('idNumber')) or (colPickMode==1 and !item.containsKey('idNumber'))">
-                            when a.id=#{item.id} then #{item.idNumber}
-                        </if>
-                    </foreach>
-                </trim>
-                        <trim prefix="isBooking=(case" suffix="ELSE isBooking end),">
-                            <foreach collection="data.dataList" item="item" index="index" separator="" >
-                                <choose>
-                                    <when test="(colPickMode==0 and item.containsKey('isBooking')) or (colPickMode==1 and !item.containsKey('isBooking'))">
-                                        when a.id=#{item.id} then #{item.isBooking}
-                                    </when>
-                                    <when test="(colPickMode==0 and item.containsKey('isBookingIncrement')) or (colPickMode==1 and !item.containsKey('isBookingIncrement'))">
-                                        when a.id=#{item.id} then ifnull(a.isBooking,0) + #{item.isBookingIncrement}
-                                    </when>
-                                </choose>
-                            </foreach>
-                        </trim>
-                <trim prefix="queueNum=(case" suffix="ELSE queueNum end),">
-                    <foreach collection="data.dataList" item="item" index="index" separator="" >
-                        <if test="(colPickMode==0 and item.containsKey('queueNum')) or (colPickMode==1 and !item.containsKey('queueNum'))">
-                            when a.id=#{item.id} then #{item.queueNum}
-                        </if>
-                    </foreach>
-                </trim>
-                <trim prefix="location=(case" suffix="ELSE location end),">
-                    <foreach collection="data.dataList" item="item" index="index" separator="" >
-                        <if test="(colPickMode==0 and item.containsKey('location')) or (colPickMode==1 and !item.containsKey('location'))">
-                            when a.id=#{item.id} then #{item.location}
-                        </if>
-                    </foreach>
-                </trim>
-                <trim prefix="picture=(case" suffix="ELSE picture end),">
-                    <foreach collection="data.dataList" item="item" index="index" separator="" >
-                        <if test="(colPickMode==0 and item.containsKey('picture')) or (colPickMode==1 and !item.containsKey('picture'))">
-                            when a.id=#{item.id} then #{item.picture}
-                        </if>
-                    </foreach>
-                </trim>
-                <trim prefix="createTime=(case" suffix="ELSE createTime end),">
-                    <foreach collection="data.dataList" item="item" index="index" separator="" >
-                        <if test="(colPickMode==0 and item.containsKey('createTime')) or (colPickMode==1 and !item.containsKey('createTime'))">
-                            when a.id=#{item.id} then #{item.createTime}
-                        </if>
-                    </foreach>
-                </trim>
-                        <trim prefix="createUserId=(case" suffix="ELSE createUserId end),">
-                            <foreach collection="data.dataList" item="item" index="index" separator="" >
-                                <choose>
-                                    <when test="(colPickMode==0 and item.containsKey('createUserId')) or (colPickMode==1 and !item.containsKey('createUserId'))">
-                                        when a.id=#{item.id} then #{item.createUserId}
-                                    </when>
-                                    <when test="(colPickMode==0 and item.containsKey('createUserIdIncrement')) or (colPickMode==1 and !item.containsKey('createUserIdIncrement'))">
-                                        when a.id=#{item.id} then ifnull(a.createUserId,0) + #{item.createUserIdIncrement}
-                                    </when>
-                                </choose>
-                            </foreach>
-                        </trim>
-                <trim prefix="updateTime=(case" suffix="ELSE updateTime end),">
-                    <foreach collection="data.dataList" item="item" index="index" separator="" >
-                        <if test="(colPickMode==0 and item.containsKey('updateTime')) or (colPickMode==1 and !item.containsKey('updateTime'))">
-                            when a.id=#{item.id} then #{item.updateTime}
-                        </if>
-                    </foreach>
-                </trim>
-                        <trim prefix="updateUserId=(case" suffix="ELSE updateUserId end),">
-                            <foreach collection="data.dataList" item="item" index="index" separator="" >
-                                <choose>
-                                    <when test="(colPickMode==0 and item.containsKey('updateUserId')) or (colPickMode==1 and !item.containsKey('updateUserId'))">
-                                        when a.id=#{item.id} then #{item.updateUserId}
-                                    </when>
-                                    <when test="(colPickMode==0 and item.containsKey('updateUserIdIncrement')) or (colPickMode==1 and !item.containsKey('updateUserIdIncrement'))">
-                                        when a.id=#{item.id} then ifnull(a.updateUserId,0) + #{item.updateUserIdIncrement}
-                                    </when>
-                                </choose>
-                            </foreach>
-                        </trim>
+            <trim prefix="siteId=(case" suffix="ELSE siteId end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <choose>
+                        <when test="(colPickMode==0 and item.containsKey('siteId')) or (colPickMode==1 and !item.containsKey('siteId'))">
+                            when a.id=#{item.id} then #{item.siteId}
+                        </when>
+                        <when test="(colPickMode==0 and item.containsKey('siteIdIncrement')) or (colPickMode==1 and !item.containsKey('siteIdIncrement'))">
+                            when a.id=#{item.id} then ifnull(a.siteId,0) + #{item.siteIdIncrement}
+                        </when>
+                    </choose>
+                </foreach>
+            </trim>
+            <trim prefix="siteName=(case" suffix="ELSE siteName end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('siteName')) or (colPickMode==1 and !item.containsKey('siteName'))">
+                        when a.id=#{item.id} then #{item.siteName}
+                    </if>
+                </foreach>
+            </trim>
+            <trim prefix="personId=(case" suffix="ELSE personId end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <choose>
+                        <when test="(colPickMode==0 and item.containsKey('personId')) or (colPickMode==1 and !item.containsKey('personId'))">
+                            when a.id=#{item.id} then #{item.personId}
+                        </when>
+                        <when test="(colPickMode==0 and item.containsKey('personIdIncrement')) or (colPickMode==1 and !item.containsKey('personIdIncrement'))">
+                            when a.id=#{item.id} then ifnull(a.personId,0) + #{item.personIdIncrement}
+                        </when>
+                    </choose>
+                </foreach>
+            </trim>
+            <trim prefix="name=(case" suffix="ELSE name end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('name')) or (colPickMode==1 and !item.containsKey('name'))">
+                        when a.id=#{item.id} then #{item.name}
+                    </if>
+                </foreach>
+            </trim>
+            <trim prefix="device=(case" suffix="ELSE device end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('device')) or (colPickMode==1 and !item.containsKey('device'))">
+                        when a.id=#{item.id} then #{item.device}
+                    </if>
+                </foreach>
+            </trim>
+            <trim prefix="detectTime=(case" suffix="ELSE detectTime end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('detectTime')) or (colPickMode==1 and !item.containsKey('detectTime'))">
+                        when a.id=#{item.id} then #{item.detectTime}
+                    </if>
+                </foreach>
+            </trim>
+            <trim prefix="contact=(case" suffix="ELSE contact end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('contact')) or (colPickMode==1 and !item.containsKey('contact'))">
+                        when a.id=#{item.id} then #{item.contact}
+                    </if>
+                </foreach>
+            </trim>
+            <trim prefix="idNumber=(case" suffix="ELSE idNumber end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('idNumber')) or (colPickMode==1 and !item.containsKey('idNumber'))">
+                        when a.id=#{item.id} then #{item.idNumber}
+                    </if>
+                </foreach>
+            </trim>
+            <trim prefix="isBooking=(case" suffix="ELSE isBooking end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <choose>
+                        <when test="(colPickMode==0 and item.containsKey('isBooking')) or (colPickMode==1 and !item.containsKey('isBooking'))">
+                            when a.id=#{item.id} then #{item.isBooking}
+                        </when>
+                        <when test="(colPickMode==0 and item.containsKey('isBookingIncrement')) or (colPickMode==1 and !item.containsKey('isBookingIncrement'))">
+                            when a.id=#{item.id} then ifnull(a.isBooking,0) + #{item.isBookingIncrement}
+                        </when>
+                    </choose>
+                </foreach>
+            </trim>
+            <trim prefix="queueNum=(case" suffix="ELSE queueNum end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('queueNum')) or (colPickMode==1 and !item.containsKey('queueNum'))">
+                        when a.id=#{item.id} then #{item.queueNum}
+                    </if>
+                </foreach>
+            </trim>
+            <trim prefix="location=(case" suffix="ELSE location end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('location')) or (colPickMode==1 and !item.containsKey('location'))">
+                        when a.id=#{item.id} then #{item.location}
+                    </if>
+                </foreach>
+            </trim>
+            <trim prefix="picture=(case" suffix="ELSE picture end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('picture')) or (colPickMode==1 and !item.containsKey('picture'))">
+                        when a.id=#{item.id} then #{item.picture}
+                    </if>
+                </foreach>
+            </trim>
+            <trim prefix="picUri=(case" suffix="ELSE picUri end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('picUri')) or (colPickMode==1 and !item.containsKey('picUri'))">
+                        when a.id=#{item.id} then #{item.picUri}
+                    </if>
+                </foreach>
+            </trim>
+            <trim prefix="serverIndexCode=(case" suffix="ELSE serverIndexCode end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('serverIndexCode')) or (colPickMode==1 and !item.containsKey('serverIndexCode'))">
+                        when a.id=#{item.id} then #{item.serverIndexCode}
+                    </if>
+                </foreach>
+            </trim>
+            <trim prefix="eventId=(case" suffix="ELSE eventId end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('eventId')) or (colPickMode==1 and !item.containsKey('eventId'))">
+                        when a.id=#{item.id} then #{item.eventId}
+                    </if>
+                </foreach>
+            </trim>
+            <trim prefix="eventType=(case" suffix="ELSE eventType end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <choose>
+                        <when test="(colPickMode==0 and item.containsKey('eventType')) or (colPickMode==1 and !item.containsKey('eventType'))">
+                            when a.id=#{item.id} then #{item.eventType}
+                        </when>
+                        <when test="(colPickMode==0 and item.containsKey('eventTypeIncrement')) or (colPickMode==1 and !item.containsKey('eventTypeIncrement'))">
+                            when a.id=#{item.id} then ifnull(a.eventType,0) + #{item.eventTypeIncrement}
+                        </when>
+                    </choose>
+                </foreach>
+            </trim>
+            <trim prefix="createTime=(case" suffix="ELSE createTime end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('createTime')) or (colPickMode==1 and !item.containsKey('createTime'))">
+                        when a.id=#{item.id} then #{item.createTime}
+                    </if>
+                </foreach>
+            </trim>
+            <trim prefix="createUserId=(case" suffix="ELSE createUserId end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <choose>
+                        <when test="(colPickMode==0 and item.containsKey('createUserId')) or (colPickMode==1 and !item.containsKey('createUserId'))">
+                            when a.id=#{item.id} then #{item.createUserId}
+                        </when>
+                        <when test="(colPickMode==0 and item.containsKey('createUserIdIncrement')) or (colPickMode==1 and !item.containsKey('createUserIdIncrement'))">
+                            when a.id=#{item.id} then ifnull(a.createUserId,0) + #{item.createUserIdIncrement}
+                        </when>
+                    </choose>
+                </foreach>
+            </trim>
+            <trim prefix="updateTime=(case" suffix="ELSE updateTime end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('updateTime')) or (colPickMode==1 and !item.containsKey('updateTime'))">
+                        when a.id=#{item.id} then #{item.updateTime}
+                    </if>
+                </foreach>
+            </trim>
+            <trim prefix="updateUserId=(case" suffix="ELSE updateUserId end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <choose>
+                        <when test="(colPickMode==0 and item.containsKey('updateUserId')) or (colPickMode==1 and !item.containsKey('updateUserId'))">
+                            when a.id=#{item.id} then #{item.updateUserId}
+                        </when>
+                        <when test="(colPickMode==0 and item.containsKey('updateUserIdIncrement')) or (colPickMode==1 and !item.containsKey('updateUserIdIncrement'))">
+                            when a.id=#{item.id} then ifnull(a.updateUserId,0) + #{item.updateUserIdIncrement}
+                        </when>
+                    </choose>
+                </foreach>
+            </trim>
         </trim>
         where id in
         <foreach collection="data.dataList" item="item" index="index" open="(" separator="," close=")">
@@ -434,380 +498,470 @@
                 ${_conditionType_} a.id=#{${_conditionParam_}.id}
             </if>
         </if>
-            <if test="conditionParamRef.containsKey('id')">
-                <if test="conditionParamRef.id != null ">
-                    ${_conditionType_} a.id = #{${_conditionParam_}.id}
-                </if>
-                <if test="conditionParamRef.id == null">
-                    ${_conditionType_} a.id is null
-                </if>
-            </if>
-            <if test="conditionParamRef.containsKey('idList') and conditionParamRef.idList.size() > 0">
-                ${_conditionType_} a.id in
-                <foreach collection="conditionParamRef.idList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
-            </if>
-            <if test="conditionParamRef.containsKey('idNotList') and conditionParamRef.idNotList.size() > 0">
-                ${_conditionType_} a.id not in
-                <foreach collection="conditionParamRef.idNotList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
-            </if>
-            <if test="conditionParamRef.containsKey('idStart') and conditionParamRef.idStart != null">
-                ${_conditionType_} a.id <![CDATA[ >= ]]> #{${_conditionParam_}.idStart}
+        <if test="conditionParamRef.containsKey('id')">
+            <if test="conditionParamRef.id != null ">
+                ${_conditionType_} a.id = #{${_conditionParam_}.id}
             </if>
-            <if test="conditionParamRef.containsKey('idEnd') and conditionParamRef.idEnd != null">
-                ${_conditionType_} a.id <![CDATA[ <= ]]> #{${_conditionParam_}.idEnd}
+            <if test="conditionParamRef.id == null">
+                ${_conditionType_} a.id is null
             </if>
+        </if>
+        <if test="conditionParamRef.containsKey('idList') and conditionParamRef.idList.size() > 0">
+            ${_conditionType_} a.id in
+            <foreach collection="conditionParamRef.idList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('idNotList') and conditionParamRef.idNotList.size() > 0">
+            ${_conditionType_} a.id not in
+            <foreach collection="conditionParamRef.idNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('idStart') and conditionParamRef.idStart != null">
+            ${_conditionType_} a.id <![CDATA[ >= ]]> #{${_conditionParam_}.idStart}
+        </if>
+        <if test="conditionParamRef.containsKey('idEnd') and conditionParamRef.idEnd != null">
+            ${_conditionType_} a.id <![CDATA[ <= ]]> #{${_conditionParam_}.idEnd}
+        </if>
 
-            <if test="conditionParamRef.containsKey('siteId')">
-                <if test="conditionParamRef.siteId != null ">
-                    ${_conditionType_} a.siteId = #{${_conditionParam_}.siteId}
-                </if>
-                <if test="conditionParamRef.siteId == null">
-                    ${_conditionType_} a.siteId is null
-                </if>
+        <if test="conditionParamRef.containsKey('siteId')">
+            <if test="conditionParamRef.siteId != null ">
+                ${_conditionType_} a.siteId = #{${_conditionParam_}.siteId}
             </if>
-            <if test="conditionParamRef.containsKey('siteIdList') and conditionParamRef.siteIdList.size() > 0">
-                ${_conditionType_} a.siteId in
-                <foreach collection="conditionParamRef.siteIdList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
-            </if>
-            <if test="conditionParamRef.containsKey('siteIdNotList') and conditionParamRef.siteIdNotList.size() > 0">
-                ${_conditionType_} a.siteId not in
-                <foreach collection="conditionParamRef.siteIdNotList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
-            </if>
-            <if test="conditionParamRef.containsKey('siteIdStart') and conditionParamRef.siteIdStart != null">
-                ${_conditionType_} a.siteId <![CDATA[ >= ]]> #{${_conditionParam_}.siteIdStart}
-            </if>
-            <if test="conditionParamRef.containsKey('siteIdEnd') and conditionParamRef.siteIdEnd != null">
-                ${_conditionType_} a.siteId <![CDATA[ <= ]]> #{${_conditionParam_}.siteIdEnd}
+            <if test="conditionParamRef.siteId == null">
+                ${_conditionType_} a.siteId is null
             </if>
+        </if>
+        <if test="conditionParamRef.containsKey('siteIdList') and conditionParamRef.siteIdList.size() > 0">
+            ${_conditionType_} a.siteId in
+            <foreach collection="conditionParamRef.siteIdList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('siteIdNotList') and conditionParamRef.siteIdNotList.size() > 0">
+            ${_conditionType_} a.siteId not in
+            <foreach collection="conditionParamRef.siteIdNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('siteIdStart') and conditionParamRef.siteIdStart != null">
+            ${_conditionType_} a.siteId <![CDATA[ >= ]]> #{${_conditionParam_}.siteIdStart}
+        </if>
+        <if test="conditionParamRef.containsKey('siteIdEnd') and conditionParamRef.siteIdEnd != null">
+            ${_conditionType_} a.siteId <![CDATA[ <= ]]> #{${_conditionParam_}.siteIdEnd}
+        </if>
 
 
-            <if test="conditionParamRef.containsKey('siteName')">
-                <if test="conditionParamRef.siteName != null and conditionParamRef.siteName != ''">
-                    ${_conditionType_} a.siteName like #{${_conditionParam_}.siteName}
-                </if>
-                <if test="conditionParamRef.siteName == null">
-                    ${_conditionType_} a.siteName is null
-                </if>
-            </if>
-            <if test="conditionParamRef.containsKey('siteNameList') and conditionParamRef.siteNameList.size() > 0">
-                ${_conditionType_} a.siteName in
-                <foreach collection="conditionParamRef.siteNameList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
-            </if>
-            <if test="conditionParamRef.containsKey('siteNameNotList') and conditionParamRef.siteNameNotList.size() > 0">
-                ${_conditionType_} a.siteName not in
-                <foreach collection="conditionParamRef.siteNameNotList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
+        <if test="conditionParamRef.containsKey('siteName')">
+            <if test="conditionParamRef.siteName != null and conditionParamRef.siteName != ''">
+                ${_conditionType_} a.siteName like #{${_conditionParam_}.siteName}
             </if>
-            <if test="conditionParamRef.containsKey('personId')">
-                <if test="conditionParamRef.personId != null ">
-                    ${_conditionType_} a.personId = #{${_conditionParam_}.personId}
-                </if>
-                <if test="conditionParamRef.personId == null">
-                    ${_conditionType_} a.personId is null
-                </if>
-            </if>
-            <if test="conditionParamRef.containsKey('personIdList') and conditionParamRef.personIdList.size() > 0">
-                ${_conditionType_} a.personId in
-                <foreach collection="conditionParamRef.personIdList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
+            <if test="conditionParamRef.siteName == null">
+                ${_conditionType_} a.siteName is null
             </if>
-            <if test="conditionParamRef.containsKey('personIdNotList') and conditionParamRef.personIdNotList.size() > 0">
-                ${_conditionType_} a.personId not in
-                <foreach collection="conditionParamRef.personIdNotList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
-            </if>
-            <if test="conditionParamRef.containsKey('personIdStart') and conditionParamRef.personIdStart != null">
-                ${_conditionType_} a.personId <![CDATA[ >= ]]> #{${_conditionParam_}.personIdStart}
+        </if>
+        <if test="conditionParamRef.containsKey('siteNameList') and conditionParamRef.siteNameList.size() > 0">
+            ${_conditionType_} a.siteName in
+            <foreach collection="conditionParamRef.siteNameList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('siteNameNotList') and conditionParamRef.siteNameNotList.size() > 0">
+            ${_conditionType_} a.siteName not in
+            <foreach collection="conditionParamRef.siteNameNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('personId')">
+            <if test="conditionParamRef.personId != null ">
+                ${_conditionType_} a.personId = #{${_conditionParam_}.personId}
             </if>
-            <if test="conditionParamRef.containsKey('personIdEnd') and conditionParamRef.personIdEnd != null">
-                ${_conditionType_} a.personId <![CDATA[ <= ]]> #{${_conditionParam_}.personIdEnd}
+            <if test="conditionParamRef.personId == null">
+                ${_conditionType_} a.personId is null
             </if>
+        </if>
+        <if test="conditionParamRef.containsKey('personIdList') and conditionParamRef.personIdList.size() > 0">
+            ${_conditionType_} a.personId in
+            <foreach collection="conditionParamRef.personIdList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('personIdNotList') and conditionParamRef.personIdNotList.size() > 0">
+            ${_conditionType_} a.personId not in
+            <foreach collection="conditionParamRef.personIdNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('personIdStart') and conditionParamRef.personIdStart != null">
+            ${_conditionType_} a.personId <![CDATA[ >= ]]> #{${_conditionParam_}.personIdStart}
+        </if>
+        <if test="conditionParamRef.containsKey('personIdEnd') and conditionParamRef.personIdEnd != null">
+            ${_conditionType_} a.personId <![CDATA[ <= ]]> #{${_conditionParam_}.personIdEnd}
+        </if>
 
 
-            <if test="conditionParamRef.containsKey('name')">
-                <if test="conditionParamRef.name != null and conditionParamRef.name != ''">
-                    ${_conditionType_} a.name like #{${_conditionParam_}.name}
-                </if>
-                <if test="conditionParamRef.name == null">
-                    ${_conditionType_} a.name is null
-                </if>
+        <if test="conditionParamRef.containsKey('name')">
+            <if test="conditionParamRef.name != null and conditionParamRef.name != ''">
+                ${_conditionType_} a.name like #{${_conditionParam_}.name}
             </if>
-            <if test="conditionParamRef.containsKey('nameList') and conditionParamRef.nameList.size() > 0">
-                ${_conditionType_} a.name in
-                <foreach collection="conditionParamRef.nameList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
-            </if>
-            <if test="conditionParamRef.containsKey('nameNotList') and conditionParamRef.nameNotList.size() > 0">
-                ${_conditionType_} a.name not in
-                <foreach collection="conditionParamRef.nameNotList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
+            <if test="conditionParamRef.name == null">
+                ${_conditionType_} a.name is null
             </if>
+        </if>
+        <if test="conditionParamRef.containsKey('nameList') and conditionParamRef.nameList.size() > 0">
+            ${_conditionType_} a.name in
+            <foreach collection="conditionParamRef.nameList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('nameNotList') and conditionParamRef.nameNotList.size() > 0">
+            ${_conditionType_} a.name not in
+            <foreach collection="conditionParamRef.nameNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
-            <if test="conditionParamRef.containsKey('device')">
-                <if test="conditionParamRef.device != null and conditionParamRef.device != ''">
-                    ${_conditionType_} a.device like #{${_conditionParam_}.device}
-                </if>
-                <if test="conditionParamRef.device == null">
-                    ${_conditionType_} a.device is null
-                </if>
+        <if test="conditionParamRef.containsKey('device')">
+            <if test="conditionParamRef.device != null and conditionParamRef.device != ''">
+                ${_conditionType_} a.device like #{${_conditionParam_}.device}
             </if>
-            <if test="conditionParamRef.containsKey('deviceList') and conditionParamRef.deviceList.size() > 0">
-                ${_conditionType_} a.device in
-                <foreach collection="conditionParamRef.deviceList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
-            </if>
-            <if test="conditionParamRef.containsKey('deviceNotList') and conditionParamRef.deviceNotList.size() > 0">
-                ${_conditionType_} a.device not in
-                <foreach collection="conditionParamRef.deviceNotList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
+            <if test="conditionParamRef.device == null">
+                ${_conditionType_} a.device is null
             </if>
+        </if>
+        <if test="conditionParamRef.containsKey('deviceList') and conditionParamRef.deviceList.size() > 0">
+            ${_conditionType_} a.device in
+            <foreach collection="conditionParamRef.deviceList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('deviceNotList') and conditionParamRef.deviceNotList.size() > 0">
+            ${_conditionType_} a.device not in
+            <foreach collection="conditionParamRef.deviceNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
-            <if test="conditionParamRef.containsKey('detectTime')">
-                <if test="conditionParamRef.detectTime != null ">
-                    ${_conditionType_} a.detectTime = #{${_conditionParam_}.detectTime}
-                </if>
-                <if test="conditionParamRef.detectTime == null">
-                    ${_conditionType_} a.detectTime is null
-                </if>
+        <if test="conditionParamRef.containsKey('detectTime')">
+            <if test="conditionParamRef.detectTime != null ">
+                ${_conditionType_} a.detectTime = #{${_conditionParam_}.detectTime}
             </if>
-            <if test="conditionParamRef.containsKey('detectTimeStart') and conditionParamRef.detectTimeStart != null and conditionParamRef.detectTimeStart!=''">
-                ${_conditionType_} a.detectTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.detectTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
-            </if>
-            <if test="conditionParamRef.containsKey('detectTimeEnd') and conditionParamRef.detectTimeEnd != null and conditionParamRef.detectTimeEnd!=''">
-                ${_conditionType_} a.detectTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.detectTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
+            <if test="conditionParamRef.detectTime == null">
+                ${_conditionType_} a.detectTime is null
             </if>
+        </if>
+        <if test="conditionParamRef.containsKey('detectTimeStart') and conditionParamRef.detectTimeStart != null and conditionParamRef.detectTimeStart!=''">
+            ${_conditionType_} a.detectTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.detectTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
+        </if>
+        <if test="conditionParamRef.containsKey('detectTimeEnd') and conditionParamRef.detectTimeEnd != null and conditionParamRef.detectTimeEnd!=''">
+            ${_conditionType_} a.detectTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.detectTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
+        </if>
 
-            <if test="conditionParamRef.containsKey('contact')">
-                <if test="conditionParamRef.contact != null and conditionParamRef.contact != ''">
-                    ${_conditionType_} a.contact like #{${_conditionParam_}.contact}
-                </if>
-                <if test="conditionParamRef.contact == null">
-                    ${_conditionType_} a.contact is null
-                </if>
-            </if>
-            <if test="conditionParamRef.containsKey('contactList') and conditionParamRef.contactList.size() > 0">
-                ${_conditionType_} a.contact in
-                <foreach collection="conditionParamRef.contactList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
+        <if test="conditionParamRef.containsKey('contact')">
+            <if test="conditionParamRef.contact != null and conditionParamRef.contact != ''">
+                ${_conditionType_} a.contact like #{${_conditionParam_}.contact}
             </if>
-            <if test="conditionParamRef.containsKey('contactNotList') and conditionParamRef.contactNotList.size() > 0">
-                ${_conditionType_} a.contact not in
-                <foreach collection="conditionParamRef.contactNotList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
+            <if test="conditionParamRef.contact == null">
+                ${_conditionType_} a.contact is null
             </if>
+        </if>
+        <if test="conditionParamRef.containsKey('contactList') and conditionParamRef.contactList.size() > 0">
+            ${_conditionType_} a.contact in
+            <foreach collection="conditionParamRef.contactList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('contactNotList') and conditionParamRef.contactNotList.size() > 0">
+            ${_conditionType_} a.contact not in
+            <foreach collection="conditionParamRef.contactNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
-            <if test="conditionParamRef.containsKey('idNumber')">
-                <if test="conditionParamRef.idNumber != null and conditionParamRef.idNumber != ''">
-                    ${_conditionType_} a.idNumber like #{${_conditionParam_}.idNumber}
-                </if>
-                <if test="conditionParamRef.idNumber == null">
-                    ${_conditionType_} a.idNumber is null
-                </if>
+        <if test="conditionParamRef.containsKey('idNumber')">
+            <if test="conditionParamRef.idNumber != null and conditionParamRef.idNumber != ''">
+                ${_conditionType_} a.idNumber like #{${_conditionParam_}.idNumber}
             </if>
-            <if test="conditionParamRef.containsKey('idNumberList') and conditionParamRef.idNumberList.size() > 0">
-                ${_conditionType_} a.idNumber in
-                <foreach collection="conditionParamRef.idNumberList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
-            </if>
-            <if test="conditionParamRef.containsKey('idNumberNotList') and conditionParamRef.idNumberNotList.size() > 0">
-                ${_conditionType_} a.idNumber not in
-                <foreach collection="conditionParamRef.idNumberNotList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
+            <if test="conditionParamRef.idNumber == null">
+                ${_conditionType_} a.idNumber is null
             </if>
-            <if test="conditionParamRef.containsKey('isBooking')">
-                <if test="conditionParamRef.isBooking != null ">
-                    ${_conditionType_} a.isBooking = #{${_conditionParam_}.isBooking}
-                </if>
-                <if test="conditionParamRef.isBooking == null">
-                    ${_conditionType_} a.isBooking is null
-                </if>
-            </if>
-            <if test="conditionParamRef.containsKey('isBookingList') and conditionParamRef.isBookingList.size() > 0">
-                ${_conditionType_} a.isBooking in
-                <foreach collection="conditionParamRef.isBookingList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
-            </if>
-            <if test="conditionParamRef.containsKey('isBookingNotList') and conditionParamRef.isBookingNotList.size() > 0">
-                ${_conditionType_} a.isBooking not in
-                <foreach collection="conditionParamRef.isBookingNotList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
-            </if>
-            <if test="conditionParamRef.containsKey('isBookingStart') and conditionParamRef.isBookingStart != null">
-                ${_conditionType_} a.isBooking <![CDATA[ >= ]]> #{${_conditionParam_}.isBookingStart}
+        </if>
+        <if test="conditionParamRef.containsKey('idNumberList') and conditionParamRef.idNumberList.size() > 0">
+            ${_conditionType_} a.idNumber in
+            <foreach collection="conditionParamRef.idNumberList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('idNumberNotList') and conditionParamRef.idNumberNotList.size() > 0">
+            ${_conditionType_} a.idNumber not in
+            <foreach collection="conditionParamRef.idNumberNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('isBooking')">
+            <if test="conditionParamRef.isBooking != null ">
+                ${_conditionType_} a.isBooking = #{${_conditionParam_}.isBooking}
             </if>
-            <if test="conditionParamRef.containsKey('isBookingEnd') and conditionParamRef.isBookingEnd != null">
-                ${_conditionType_} a.isBooking <![CDATA[ <= ]]> #{${_conditionParam_}.isBookingEnd}
+            <if test="conditionParamRef.isBooking == null">
+                ${_conditionType_} a.isBooking is null
             </if>
+        </if>
+        <if test="conditionParamRef.containsKey('isBookingList') and conditionParamRef.isBookingList.size() > 0">
+            ${_conditionType_} a.isBooking in
+            <foreach collection="conditionParamRef.isBookingList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('isBookingNotList') and conditionParamRef.isBookingNotList.size() > 0">
+            ${_conditionType_} a.isBooking not in
+            <foreach collection="conditionParamRef.isBookingNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('isBookingStart') and conditionParamRef.isBookingStart != null">
+            ${_conditionType_} a.isBooking <![CDATA[ >= ]]> #{${_conditionParam_}.isBookingStart}
+        </if>
+        <if test="conditionParamRef.containsKey('isBookingEnd') and conditionParamRef.isBookingEnd != null">
+            ${_conditionType_} a.isBooking <![CDATA[ <= ]]> #{${_conditionParam_}.isBookingEnd}
+        </if>
 
 
-            <if test="conditionParamRef.containsKey('queueNum')">
-                <if test="conditionParamRef.queueNum != null and conditionParamRef.queueNum != ''">
-                    ${_conditionType_} a.queueNum like #{${_conditionParam_}.queueNum}
-                </if>
-                <if test="conditionParamRef.queueNum == null">
-                    ${_conditionType_} a.queueNum is null
-                </if>
+        <if test="conditionParamRef.containsKey('queueNum')">
+            <if test="conditionParamRef.queueNum != null and conditionParamRef.queueNum != ''">
+                ${_conditionType_} a.queueNum like #{${_conditionParam_}.queueNum}
             </if>
-            <if test="conditionParamRef.containsKey('queueNumList') and conditionParamRef.queueNumList.size() > 0">
-                ${_conditionType_} a.queueNum in
-                <foreach collection="conditionParamRef.queueNumList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
-            </if>
-            <if test="conditionParamRef.containsKey('queueNumNotList') and conditionParamRef.queueNumNotList.size() > 0">
-                ${_conditionType_} a.queueNum not in
-                <foreach collection="conditionParamRef.queueNumNotList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
+            <if test="conditionParamRef.queueNum == null">
+                ${_conditionType_} a.queueNum is null
             </if>
+        </if>
+        <if test="conditionParamRef.containsKey('queueNumList') and conditionParamRef.queueNumList.size() > 0">
+            ${_conditionType_} a.queueNum in
+            <foreach collection="conditionParamRef.queueNumList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('queueNumNotList') and conditionParamRef.queueNumNotList.size() > 0">
+            ${_conditionType_} a.queueNum not in
+            <foreach collection="conditionParamRef.queueNumNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
-            <if test="conditionParamRef.containsKey('location')">
-                <if test="conditionParamRef.location != null and conditionParamRef.location != ''">
-                    ${_conditionType_} a.location like #{${_conditionParam_}.location}
-                </if>
-                <if test="conditionParamRef.location == null">
-                    ${_conditionType_} a.location is null
-                </if>
+        <if test="conditionParamRef.containsKey('location')">
+            <if test="conditionParamRef.location != null and conditionParamRef.location != ''">
+                ${_conditionType_} a.location like #{${_conditionParam_}.location}
             </if>
-            <if test="conditionParamRef.containsKey('locationList') and conditionParamRef.locationList.size() > 0">
-                ${_conditionType_} a.location in
-                <foreach collection="conditionParamRef.locationList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
-            </if>
-            <if test="conditionParamRef.containsKey('locationNotList') and conditionParamRef.locationNotList.size() > 0">
-                ${_conditionType_} a.location not in
-                <foreach collection="conditionParamRef.locationNotList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
+            <if test="conditionParamRef.location == null">
+                ${_conditionType_} a.location is null
             </if>
+        </if>
+        <if test="conditionParamRef.containsKey('locationList') and conditionParamRef.locationList.size() > 0">
+            ${_conditionType_} a.location in
+            <foreach collection="conditionParamRef.locationList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('locationNotList') and conditionParamRef.locationNotList.size() > 0">
+            ${_conditionType_} a.location not in
+            <foreach collection="conditionParamRef.locationNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
-            <if test="conditionParamRef.containsKey('picture')">
-                <if test="conditionParamRef.picture != null and conditionParamRef.picture != ''">
-                    ${_conditionType_} a.picture like #{${_conditionParam_}.picture}
-                </if>
-                <if test="conditionParamRef.picture == null">
-                    ${_conditionType_} a.picture is null
-                </if>
+        <if test="conditionParamRef.containsKey('picture')">
+            <if test="conditionParamRef.picture != null and conditionParamRef.picture != ''">
+                ${_conditionType_} a.picture like #{${_conditionParam_}.picture}
             </if>
-            <if test="conditionParamRef.containsKey('pictureList') and conditionParamRef.pictureList.size() > 0">
-                ${_conditionType_} a.picture in
-                <foreach collection="conditionParamRef.pictureList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
-            </if>
-            <if test="conditionParamRef.containsKey('pictureNotList') and conditionParamRef.pictureNotList.size() > 0">
-                ${_conditionType_} a.picture not in
-                <foreach collection="conditionParamRef.pictureNotList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
+            <if test="conditionParamRef.picture == null">
+                ${_conditionType_} a.picture is null
             </if>
+        </if>
+        <if test="conditionParamRef.containsKey('pictureList') and conditionParamRef.pictureList.size() > 0">
+            ${_conditionType_} a.picture in
+            <foreach collection="conditionParamRef.pictureList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('pictureNotList') and conditionParamRef.pictureNotList.size() > 0">
+            ${_conditionType_} a.picture not in
+            <foreach collection="conditionParamRef.pictureNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
-            <if test="conditionParamRef.containsKey('createTime')">
-                <if test="conditionParamRef.createTime != null ">
-                    ${_conditionType_} a.createTime = #{${_conditionParam_}.createTime}
-                </if>
-                <if test="conditionParamRef.createTime == null">
-                    ${_conditionType_} a.createTime is null
-                </if>
+        <if test="conditionParamRef.containsKey('picUri')">
+            <if test="conditionParamRef.picUri != null and conditionParamRef.picUri != ''">
+                ${_conditionType_} a.picUri like #{${_conditionParam_}.picUri}
             </if>
-            <if test="conditionParamRef.containsKey('createTimeStart') and conditionParamRef.createTimeStart != null and conditionParamRef.createTimeStart!=''">
-                ${_conditionType_} a.createTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
+            <if test="conditionParamRef.picUri == null">
+                ${_conditionType_} a.picUri is null
             </if>
-            <if test="conditionParamRef.containsKey('createTimeEnd') and conditionParamRef.createTimeEnd != null and conditionParamRef.createTimeEnd!=''">
-                ${_conditionType_} a.createTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
+        </if>
+        <if test="conditionParamRef.containsKey('picUriList') and conditionParamRef.picUriList.size() > 0">
+            ${_conditionType_} a.picUri in
+            <foreach collection="conditionParamRef.picUriList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('picUriNotList') and conditionParamRef.picUriNotList.size() > 0">
+            ${_conditionType_} a.picUri not in
+            <foreach collection="conditionParamRef.picUriNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+
+        <if test="conditionParamRef.containsKey('serverIndexCode')">
+            <if test="conditionParamRef.serverIndexCode != null and conditionParamRef.serverIndexCode != ''">
+                ${_conditionType_} a.serverIndexCode like #{${_conditionParam_}.serverIndexCode}
             </if>
-            <if test="conditionParamRef.containsKey('createUserId')">
-                <if test="conditionParamRef.createUserId != null ">
-                    ${_conditionType_} a.createUserId = #{${_conditionParam_}.createUserId}
-                </if>
-                <if test="conditionParamRef.createUserId == null">
-                    ${_conditionType_} a.createUserId is null
-                </if>
+            <if test="conditionParamRef.serverIndexCode == null">
+                ${_conditionType_} a.serverIndexCode is null
             </if>
-            <if test="conditionParamRef.containsKey('createUserIdList') and conditionParamRef.createUserIdList.size() > 0">
-                ${_conditionType_} a.createUserId in
-                <foreach collection="conditionParamRef.createUserIdList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('serverIndexCodeList') and conditionParamRef.serverIndexCodeList.size() > 0">
+            ${_conditionType_} a.serverIndexCode in
+            <foreach collection="conditionParamRef.serverIndexCodeList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('serverIndexCodeNotList') and conditionParamRef.serverIndexCodeNotList.size() > 0">
+            ${_conditionType_} a.serverIndexCode not in
+            <foreach collection="conditionParamRef.serverIndexCodeNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+
+        <if test="conditionParamRef.containsKey('eventId')">
+            <if test="conditionParamRef.eventId != null and conditionParamRef.eventId != ''">
+                ${_conditionType_} a.eventId like #{${_conditionParam_}.eventId}
             </if>
-            <if test="conditionParamRef.containsKey('createUserIdNotList') and conditionParamRef.createUserIdNotList.size() > 0">
-                ${_conditionType_} a.createUserId not in
-                <foreach collection="conditionParamRef.createUserIdNotList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
+            <if test="conditionParamRef.eventId == null">
+                ${_conditionType_} a.eventId is null
             </if>
-            <if test="conditionParamRef.containsKey('createUserIdStart') and conditionParamRef.createUserIdStart != null">
-                ${_conditionType_} a.createUserId <![CDATA[ >= ]]> #{${_conditionParam_}.createUserIdStart}
+        </if>
+        <if test="conditionParamRef.containsKey('eventIdList') and conditionParamRef.eventIdList.size() > 0">
+            ${_conditionType_} a.eventId in
+            <foreach collection="conditionParamRef.eventIdList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('eventIdNotList') and conditionParamRef.eventIdNotList.size() > 0">
+            ${_conditionType_} a.eventId not in
+            <foreach collection="conditionParamRef.eventIdNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('eventType')">
+            <if test="conditionParamRef.eventType != null ">
+                ${_conditionType_} a.eventType = #{${_conditionParam_}.eventType}
             </if>
-            <if test="conditionParamRef.containsKey('createUserIdEnd') and conditionParamRef.createUserIdEnd != null">
-                ${_conditionType_} a.createUserId <![CDATA[ <= ]]> #{${_conditionParam_}.createUserIdEnd}
+            <if test="conditionParamRef.eventType == null">
+                ${_conditionType_} a.eventType is null
             </if>
+        </if>
+        <if test="conditionParamRef.containsKey('eventTypeList') and conditionParamRef.eventTypeList.size() > 0">
+            ${_conditionType_} a.eventType in
+            <foreach collection="conditionParamRef.eventTypeList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('eventTypeNotList') and conditionParamRef.eventTypeNotList.size() > 0">
+            ${_conditionType_} a.eventType not in
+            <foreach collection="conditionParamRef.eventTypeNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('eventTypeStart') and conditionParamRef.eventTypeStart != null">
+            ${_conditionType_} a.eventType <![CDATA[ >= ]]> #{${_conditionParam_}.eventTypeStart}
+        </if>
+        <if test="conditionParamRef.containsKey('eventTypeEnd') and conditionParamRef.eventTypeEnd != null">
+            ${_conditionType_} a.eventType <![CDATA[ <= ]]> #{${_conditionParam_}.eventTypeEnd}
+        </if>
 
 
-            <if test="conditionParamRef.containsKey('updateTime')">
-                <if test="conditionParamRef.updateTime != null ">
-                    ${_conditionType_} a.updateTime = #{${_conditionParam_}.updateTime}
-                </if>
-                <if test="conditionParamRef.updateTime == null">
-                    ${_conditionType_} a.updateTime is null
-                </if>
+        <if test="conditionParamRef.containsKey('createTime')">
+            <if test="conditionParamRef.createTime != null ">
+                ${_conditionType_} a.createTime = #{${_conditionParam_}.createTime}
             </if>
-            <if test="conditionParamRef.containsKey('updateTimeStart') and conditionParamRef.updateTimeStart != null and conditionParamRef.updateTimeStart!=''">
-                ${_conditionType_} a.updateTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
+            <if test="conditionParamRef.createTime == null">
+                ${_conditionType_} a.createTime is null
             </if>
-            <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('createTimeStart') and conditionParamRef.createTimeStart != null and conditionParamRef.createTimeStart!=''">
+            ${_conditionType_} a.createTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
+        </if>
+        <if test="conditionParamRef.containsKey('createTimeEnd') and conditionParamRef.createTimeEnd != null and conditionParamRef.createTimeEnd!=''">
+            ${_conditionType_} a.createTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
+        </if>
+        <if test="conditionParamRef.containsKey('createUserId')">
+            <if test="conditionParamRef.createUserId != null ">
+                ${_conditionType_} a.createUserId = #{${_conditionParam_}.createUserId}
             </if>
-            <if test="conditionParamRef.containsKey('updateUserId')">
-                <if test="conditionParamRef.updateUserId != null ">
-                    ${_conditionType_} a.updateUserId = #{${_conditionParam_}.updateUserId}
-                </if>
-                <if test="conditionParamRef.updateUserId == null">
-                    ${_conditionType_} a.updateUserId is null
-                </if>
+            <if test="conditionParamRef.createUserId == null">
+                ${_conditionType_} a.createUserId is null
             </if>
-            <if test="conditionParamRef.containsKey('updateUserIdList') and conditionParamRef.updateUserIdList.size() > 0">
-                ${_conditionType_} a.updateUserId in
-                <foreach collection="conditionParamRef.updateUserIdList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('createUserIdList') and conditionParamRef.createUserIdList.size() > 0">
+            ${_conditionType_} a.createUserId in
+            <foreach collection="conditionParamRef.createUserIdList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('createUserIdNotList') and conditionParamRef.createUserIdNotList.size() > 0">
+            ${_conditionType_} a.createUserId not in
+            <foreach collection="conditionParamRef.createUserIdNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('createUserIdStart') and conditionParamRef.createUserIdStart != null">
+            ${_conditionType_} a.createUserId <![CDATA[ >= ]]> #{${_conditionParam_}.createUserIdStart}
+        </if>
+        <if test="conditionParamRef.containsKey('createUserIdEnd') and conditionParamRef.createUserIdEnd != null">
+            ${_conditionType_} a.createUserId <![CDATA[ <= ]]> #{${_conditionParam_}.createUserIdEnd}
+        </if>
+
+
+        <if test="conditionParamRef.containsKey('updateTime')">
+            <if test="conditionParamRef.updateTime != null ">
+                ${_conditionType_} a.updateTime = #{${_conditionParam_}.updateTime}
             </if>
-            <if test="conditionParamRef.containsKey('updateUserIdNotList') and conditionParamRef.updateUserIdNotList.size() > 0">
-                ${_conditionType_} a.updateUserId not in
-                <foreach collection="conditionParamRef.updateUserIdNotList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
+            <if test="conditionParamRef.updateTime == null">
+                ${_conditionType_} a.updateTime is null
             </if>
-            <if test="conditionParamRef.containsKey('updateUserIdStart') and conditionParamRef.updateUserIdStart != null">
-                ${_conditionType_} a.updateUserId <![CDATA[ >= ]]> #{${_conditionParam_}.updateUserIdStart}
+        </if>
+        <if test="conditionParamRef.containsKey('updateTimeStart') and conditionParamRef.updateTimeStart != null and conditionParamRef.updateTimeStart!=''">
+            ${_conditionType_} a.updateTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
+        </if>
+        <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('updateUserId')">
+            <if test="conditionParamRef.updateUserId != null ">
+                ${_conditionType_} a.updateUserId = #{${_conditionParam_}.updateUserId}
             </if>
-            <if test="conditionParamRef.containsKey('updateUserIdEnd') and conditionParamRef.updateUserIdEnd != null">
-                ${_conditionType_} a.updateUserId <![CDATA[ <= ]]> #{${_conditionParam_}.updateUserIdEnd}
+            <if test="conditionParamRef.updateUserId == null">
+                ${_conditionType_} a.updateUserId is null
             </if>
+        </if>
+        <if test="conditionParamRef.containsKey('updateUserIdList') and conditionParamRef.updateUserIdList.size() > 0">
+            ${_conditionType_} a.updateUserId in
+            <foreach collection="conditionParamRef.updateUserIdList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('updateUserIdNotList') and conditionParamRef.updateUserIdNotList.size() > 0">
+            ${_conditionType_} a.updateUserId not in
+            <foreach collection="conditionParamRef.updateUserIdNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('updateUserIdStart') and conditionParamRef.updateUserIdStart != null">
+            ${_conditionType_} a.updateUserId <![CDATA[ >= ]]> #{${_conditionParam_}.updateUserIdStart}
+        </if>
+        <if test="conditionParamRef.containsKey('updateUserIdEnd') and conditionParamRef.updateUserIdEnd != null">
+            ${_conditionType_} a.updateUserId <![CDATA[ <= ]]> #{${_conditionParam_}.updateUserIdEnd}
+        </if>
 
     </sql>
     <sql id="_orderCols_">
@@ -815,98 +969,118 @@
             order by
             <trim suffixOverrides=","  suffix="">
                 <foreach collection="orderColList" open="" close="" index="index" item="item" separator=",">
-                     ${item.colName} ${item.sortKind}
+                    ${item.colName} ${item.sortKind}
                 </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
-                        <if test='orderCol.id != null and "DESC".equalsIgnoreCase(orderCol.id)'>DESC</if>
-                        ,
-                    </if>
-                    <if test="orderCol.containsKey('siteId')">
-                        a.siteId
-                        <if test='orderCol.siteId != null and "DESC".equalsIgnoreCase(orderCol.siteId)'>DESC</if>
-                        ,
-                    </if>
-                    <if test="orderCol.containsKey('siteName')">
-                        a.siteName
-                        <if test='orderCol.siteName != null and "DESC".equalsIgnoreCase(orderCol.siteName)'>DESC</if>
-                        ,
-                    </if>
-                    <if test="orderCol.containsKey('personId')">
-                        a.personId
-                        <if test='orderCol.personId != null and "DESC".equalsIgnoreCase(orderCol.personId)'>DESC</if>
-                        ,
-                    </if>
-                    <if test="orderCol.containsKey('name')">
-                        a.name
-                        <if test='orderCol.name != null and "DESC".equalsIgnoreCase(orderCol.name)'>DESC</if>
-                        ,
-                    </if>
-                    <if test="orderCol.containsKey('device')">
-                        a.device
-                        <if test='orderCol.device != null and "DESC".equalsIgnoreCase(orderCol.device)'>DESC</if>
-                        ,
-                    </if>
-                    <if test="orderCol.containsKey('detectTime')">
-                        a.detectTime
-                        <if test='orderCol.detectTime != null and "DESC".equalsIgnoreCase(orderCol.detectTime)'>DESC</if>
-                        ,
-                    </if>
-                    <if test="orderCol.containsKey('contact')">
-                        a.contact
-                        <if test='orderCol.contact != null and "DESC".equalsIgnoreCase(orderCol.contact)'>DESC</if>
-                        ,
-                    </if>
-                    <if test="orderCol.containsKey('idNumber')">
-                        a.idNumber
-                        <if test='orderCol.idNumber != null and "DESC".equalsIgnoreCase(orderCol.idNumber)'>DESC</if>
-                        ,
-                    </if>
-                    <if test="orderCol.containsKey('isBooking')">
-                        a.isBooking
-                        <if test='orderCol.isBooking != null and "DESC".equalsIgnoreCase(orderCol.isBooking)'>DESC</if>
-                        ,
-                    </if>
-                    <if test="orderCol.containsKey('queueNum')">
-                        a.queueNum
-                        <if test='orderCol.queueNum != null and "DESC".equalsIgnoreCase(orderCol.queueNum)'>DESC</if>
-                        ,
-                    </if>
-                    <if test="orderCol.containsKey('location')">
-                        a.location
-                        <if test='orderCol.location != null and "DESC".equalsIgnoreCase(orderCol.location)'>DESC</if>
-                        ,
-                    </if>
-                    <if test="orderCol.containsKey('picture')">
-                        a.picture
-                        <if test='orderCol.picture != null and "DESC".equalsIgnoreCase(orderCol.picture)'>DESC</if>
-                        ,
-                    </if>
-                    <if test="orderCol.containsKey('createTime')">
-                        a.createTime
-                        <if test='orderCol.createTime != null and "DESC".equalsIgnoreCase(orderCol.createTime)'>DESC</if>
-                        ,
-                    </if>
-                    <if test="orderCol.containsKey('createUserId')">
-                        a.createUserId
-                        <if test='orderCol.createUserId != null and "DESC".equalsIgnoreCase(orderCol.createUserId)'>DESC</if>
-                        ,
-                    </if>
-                    <if test="orderCol.containsKey('updateTime')">
-                        a.updateTime
-                        <if test='orderCol.updateTime != null and "DESC".equalsIgnoreCase(orderCol.updateTime)'>DESC</if>
-                        ,
-                    </if>
-                    <if test="orderCol.containsKey('updateUserId')">
-                        a.updateUserId
-                        <if test='orderCol.updateUserId != null and "DESC".equalsIgnoreCase(orderCol.updateUserId)'>DESC</if>
-                        ,
-                    </if>
+                <if test="orderCol.containsKey('id')">
+                    a.id
+                    <if test='orderCol.id != null and "DESC".equalsIgnoreCase(orderCol.id)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('siteId')">
+                    a.siteId
+                    <if test='orderCol.siteId != null and "DESC".equalsIgnoreCase(orderCol.siteId)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('siteName')">
+                    a.siteName
+                    <if test='orderCol.siteName != null and "DESC".equalsIgnoreCase(orderCol.siteName)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('personId')">
+                    a.personId
+                    <if test='orderCol.personId != null and "DESC".equalsIgnoreCase(orderCol.personId)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('name')">
+                    a.name
+                    <if test='orderCol.name != null and "DESC".equalsIgnoreCase(orderCol.name)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('device')">
+                    a.device
+                    <if test='orderCol.device != null and "DESC".equalsIgnoreCase(orderCol.device)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('detectTime')">
+                    a.detectTime
+                    <if test='orderCol.detectTime != null and "DESC".equalsIgnoreCase(orderCol.detectTime)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('contact')">
+                    a.contact
+                    <if test='orderCol.contact != null and "DESC".equalsIgnoreCase(orderCol.contact)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('idNumber')">
+                    a.idNumber
+                    <if test='orderCol.idNumber != null and "DESC".equalsIgnoreCase(orderCol.idNumber)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('isBooking')">
+                    a.isBooking
+                    <if test='orderCol.isBooking != null and "DESC".equalsIgnoreCase(orderCol.isBooking)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('queueNum')">
+                    a.queueNum
+                    <if test='orderCol.queueNum != null and "DESC".equalsIgnoreCase(orderCol.queueNum)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('location')">
+                    a.location
+                    <if test='orderCol.location != null and "DESC".equalsIgnoreCase(orderCol.location)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('picture')">
+                    a.picture
+                    <if test='orderCol.picture != null and "DESC".equalsIgnoreCase(orderCol.picture)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('picUri')">
+                    a.picUri
+                    <if test='orderCol.picUri != null and "DESC".equalsIgnoreCase(orderCol.picUri)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('serverIndexCode')">
+                    a.serverIndexCode
+                    <if test='orderCol.serverIndexCode != null and "DESC".equalsIgnoreCase(orderCol.serverIndexCode)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('eventId')">
+                    a.eventId
+                    <if test='orderCol.eventId != null and "DESC".equalsIgnoreCase(orderCol.eventId)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('eventType')">
+                    a.eventType
+                    <if test='orderCol.eventType != null and "DESC".equalsIgnoreCase(orderCol.eventType)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('createTime')">
+                    a.createTime
+                    <if test='orderCol.createTime != null and "DESC".equalsIgnoreCase(orderCol.createTime)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('createUserId')">
+                    a.createUserId
+                    <if test='orderCol.createUserId != null and "DESC".equalsIgnoreCase(orderCol.createUserId)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('updateTime')">
+                    a.updateTime
+                    <if test='orderCol.updateTime != null and "DESC".equalsIgnoreCase(orderCol.updateTime)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('updateUserId')">
+                    a.updateUserId
+                    <if test='orderCol.updateUserId != null and "DESC".equalsIgnoreCase(orderCol.updateUserId)'>DESC</if>
+                    ,
+                </if>
             </trim>
         </if>
     </sql>