添加窗口无人值守

base-manager/db/add.sql

+
+-- ----------------------------
+2023-2-21
+-- ----------------------------
+ALTER TABLE mortals_sys_window ADD COLUMN `duty` tinyint (1)    COMMENT '无人值守(1.是，0.否)' AFTER hongqi;
+ALTER TABLE mortals_sys_window ADD COLUMN `dutyContent` varchar (256)    COMMENT '显示内容' AFTER duty;
+ALTER TABLE mortals_sys_window ADD COLUMN `dutyEnglish` varchar (256)    COMMENT '显示英文' AFTER dutyContent;
+

base-manager/src/main/java/com/mortals/xhx/module/window/model/WindowEntity.java

@@ -12,7 +12,7 @@ import com.mortals.xhx.module.window.model.vo.WindowVo;
  * 站点部门窗口实体对象
  *
  * @author zxfei
- * @date 2022-01-12
+ * @date 2023-02-21
  */
 
 public class WindowEntity extends WindowVo {
@@ -58,6 +58,18 @@ public class WindowEntity extends WindowVo {
      * 红旗窗口 (1.是，0.否)
      */
     private Integer hongqi;
+    /**
+     * 无人值守(1.是，)
+     */
+    private Integer duty;
+    /**
+     * 显示内容
+     */
+    private String dutyContent;
+    /**
+     * 显示英文
+     */
+    private String dutyEnglish;
     /**
      * 备注
      */
@@ -255,6 +267,60 @@ public class WindowEntity extends WindowVo {
         this.hongqi = hongqi;
     }
 
+    /**
+     * 获取 无人值守(1.是，)
+     *
+     * @return Integer
+     */
+    public Integer getDuty() {
+        return duty;
+    }
+
+    /**
+     * 设置 无人值守(1.是，)
+     *
+     * @param duty
+     */
+    public void setDuty(Integer duty) {
+        this.duty = duty;
+    }
+
+    /**
+     * 获取 显示内容
+     *
+     * @return String
+     */
+    public String getDutyContent() {
+        return dutyContent;
+    }
+
+    /**
+     * 设置 显示内容
+     *
+     * @param dutyContent
+     */
+    public void setDutyContent(String dutyContent) {
+        this.dutyContent = dutyContent;
+    }
+
+    /**
+     * 获取 显示英文
+     *
+     * @return String
+     */
+    public String getDutyEnglish() {
+        return dutyEnglish;
+    }
+
+    /**
+     * 设置 显示英文
+     *
+     * @param dutyEnglish
+     */
+    public void setDutyEnglish(String dutyEnglish) {
+        this.dutyEnglish = dutyEnglish;
+    }
+
     /**
      * 获取 备注
      *
@@ -339,6 +405,9 @@ public class WindowEntity extends WindowVo {
         sb.append(",englishRegion:").append(getEnglishRegion());
         sb.append(",fromnum:").append(getFromnum());
         sb.append(",hongqi:").append(getHongqi());
+        sb.append(",duty:").append(getDuty());
+        sb.append(",dutyContent:").append(getDutyContent());
+        sb.append(",dutyEnglish:").append(getDutyEnglish());
         sb.append(",summary:").append(getSummary());
         sb.append(",building:").append(getBuilding());
         sb.append(",level:").append(getLevel());
@@ -351,7 +420,7 @@ public class WindowEntity extends WindowVo {
 
         this.siteName = "";
 
-        this.deptId = 0L;
+        this.deptId = null;
 
         this.deptName = "";
 
@@ -367,6 +436,12 @@ public class WindowEntity extends WindowVo {
 
         this.hongqi = 1;
 
+        this.duty = 0;
+
+        this.dutyContent = "";
+
+        this.dutyEnglish = "";
+
         this.summary = "";
 
         this.building = 1;

base-manager/src/main/java/com/mortals/xhx/module/window/model/WindowQuery.java

@@ -3,11 +3,11 @@ package com.mortals.xhx.module.window.model;
 import java.util.List;
 import com.mortals.xhx.module.window.model.WindowEntity;
 /**
-* 站点部门窗口查询对象
-*
-* @author zxfei
-* @date 2022-01-12
-*/
+ * 站点部门窗口查询对象
+ *
+ * @author zxfei
+ * @date 2023-02-21
+ */
 public class WindowQuery extends WindowEntity {
     /** 开始 序号，主键，自增长 */
     private Long idStart;
@@ -21,6 +21,9 @@ public class WindowQuery extends WindowEntity {
     /** 序号，主键，自增长列表 */
     private List <Long> idList;
 
+    /** 序号，主键，自增长排除列表 */
+    private List <Long> idNotList;
+
     /** 开始 站点ID */
     private Long siteIdStart;
 
@@ -33,9 +36,14 @@ public class WindowQuery extends WindowEntity {
     /** 站点ID列表 */
     private List <Long> siteIdList;
 
+    /** 站点ID排除列表 */
+    private List <Long> siteIdNotList;
+
     /** 站点名称 */
     private List<String> siteNameList;
 
+    /** 站点名称排除列表 */
+    private List <String> siteNameNotList;
     /** 开始 部门ID */
     private Long deptIdStart;
 
@@ -48,24 +56,39 @@ public class WindowQuery extends WindowEntity {
     /** 部门ID列表 */
     private List <Long> deptIdList;
 
+    /** 部门ID排除列表 */
+    private List <Long> deptIdNotList;
+
     /** 部门名称 */
     private List<String> deptNameList;
 
+    /** 部门名称排除列表 */
+    private List <String> deptNameNotList;
     /** 窗口名称 */
     private List<String> nameList;
 
+    /** 窗口名称排除列表 */
+    private List <String> nameNotList;
     /** 英语窗口名 */
     private List<String> englishNameList;
 
+    /** 英语窗口名排除列表 */
+    private List <String> englishNameNotList;
     /** 区域 */
     private List<String> regionList;
 
+    /** 区域排除列表 */
+    private List <String> regionNotList;
     /** 英语区域 */
     private List<String> englishRegionList;
 
+    /** 英语区域排除列表 */
+    private List <String> englishRegionNotList;
     /** 窗口编号 */
     private List<String> fromnumList;
 
+    /** 窗口编号排除列表 */
+    private List <String> fromnumNotList;
     /** 开始 红旗窗口 (1.是，0.否) */
     private Integer hongqiStart;
 
@@ -78,9 +101,39 @@ public class WindowQuery extends WindowEntity {
     /** 红旗窗口 (1.是，0.否)列表 */
     private List <Integer> hongqiList;
 
+    /** 红旗窗口 (1.是，0.否)排除列表 */
+    private List <Integer> hongqiNotList;
+
+    /** 开始 无人值守(1.是，) */
+    private Integer dutyStart;
+
+    /** 结束 无人值守(1.是，) */
+    private Integer dutyEnd;
+
+    /** 增加 无人值守(1.是，) */
+    private Integer dutyIncrement;
+
+    /** 无人值守(1.是，)列表 */
+    private List <Integer> dutyList;
+
+    /** 无人值守(1.是，)排除列表 */
+    private List <Integer> dutyNotList;
+
+    /** 显示内容 */
+    private List<String> dutyContentList;
+
+    /** 显示内容排除列表 */
+    private List <String> dutyContentNotList;
+    /** 显示英文 */
+    private List<String> dutyEnglishList;
+
+    /** 显示英文排除列表 */
+    private List <String> dutyEnglishNotList;
     /** 备注 */
     private List<String> summaryList;
 
+    /** 备注排除列表 */
+    private List <String> summaryNotList;
     /** 开始 楼栋 */
     private Integer buildingStart;
 
@@ -93,6 +146,9 @@ public class WindowQuery extends WindowEntity {
     /** 楼栋列表 */
     private List <Integer> buildingList;
 
+    /** 楼栋排除列表 */
+    private List <Integer> buildingNotList;
+
     /** 开始 楼层 */
     private Integer levelStart;
 
@@ -105,6 +161,9 @@ public class WindowQuery extends WindowEntity {
     /** 楼层列表 */
     private List <Integer> levelList;
 
+    /** 楼层排除列表 */
+    private List <Integer> levelNotList;
+
     /** 开始 创建时间 */
     private String createTimeStart;
 
@@ -123,6 +182,9 @@ public class WindowQuery extends WindowEntity {
     /** 创建用户列表 */
     private List <Long> createUserIdList;
 
+    /** 创建用户排除列表 */
+    private List <Long> createUserIdNotList;
+
     /** 开始 修改时间 */
     private String updateTimeStart;
 
@@ -138,1134 +200,1689 @@ public class WindowQuery extends WindowEntity {
     public WindowQuery(){}
 
     /**
-    * 获取 开始 序号，主键，自增长
-    * @return idStart
-    */
+     * 获取 开始 序号，主键，自增长
+     * @return idStart
+     */
     public Long getIdStart(){
         return this.idStart;
     }
 
     /**
-    * 设置 开始 序号，主键，自增长
-    * @param idStart
-    */
+     * 设置 开始 序号，主键，自增长
+     * @param idStart
+     */
     public void setIdStart(Long idStart){
         this.idStart = idStart;
     }
 
     /**
-    * 获取 结束 序号，主键，自增长
-    * @return $idEnd
-    */
+     * 获取 结束 序号，主键，自增长
+     * @return $idEnd
+     */
     public Long getIdEnd(){
         return this.idEnd;
     }
 
     /**
-    * 设置 结束 序号，主键，自增长
-    * @param idEnd
-    */
+     * 设置 结束 序号，主键，自增长
+     * @param idEnd
+     */
     public void setIdEnd(Long idEnd){
         this.idEnd = idEnd;
     }
 
     /**
-    * 获取 增加 序号，主键，自增长
-    * @return idIncrement
-    */
+     * 获取 增加 序号，主键，自增长
+     * @return idIncrement
+     */
     public Long getIdIncrement(){
         return this.idIncrement;
     }
 
     /**
-    * 设置 增加 序号，主键，自增长
-    * @param idIncrement
-    */
+     * 设置 增加 序号，主键，自增长
+     * @param idIncrement
+     */
     public void setIdIncrement(Long idIncrement){
         this.idIncrement = idIncrement;
     }
 
     /**
-    * 获取 序号，主键，自增长
-    * @return idList
-    */
+     * 获取 序号，主键，自增长
+     * @return idList
+     */
     public List<Long> getIdList(){
         return this.idList;
     }
 
     /**
-    * 设置 序号，主键，自增长
-    * @param idList
-    */
+     * 设置 序号，主键，自增长
+     * @param idList
+     */
     public void setIdList(List<Long> idList){
         this.idList = idList;
     }
 
     /**
-    * 获取 开始 站点ID
-    * @return siteIdStart
-    */
+     * 获取 序号，主键，自增长
+     * @return idNotList
+     */
+    public List<Long> getIdNotList(){
+        return this.idNotList;
+    }
+
+    /**
+     * 设置 序号，主键，自增长
+     * @param idNotList
+     */
+    public void setIdNotList(List<Long> idNotList){
+        this.idNotList = idNotList;
+    }
+
+
+    /**
+     * 获取 开始 站点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;
     }
 
     /**
-    * 获取 站点名称
-    * @return siteNameList
-    */
+     * 获取 站点ID
+     * @return siteIdNotList
+     */
+    public List<Long> getSiteIdNotList(){
+        return this.siteIdNotList;
+    }
+
+    /**
+     * 设置 站点ID
+     * @param siteIdNotList
+     */
+    public void setSiteIdNotList(List<Long> siteIdNotList){
+        this.siteIdNotList = siteIdNotList;
+    }
+
+
+    /**
+     * 获取 站点名称
+     * @return siteNameList
+     */
     public List<String> getSiteNameList(){
         return this.siteNameList;
     }
 
     /**
-    * 设置 站点名称
-    * @param siteNameList
-    */
+     * 设置 站点名称
+     * @param siteNameList
+     */
     public void setSiteNameList(List<String> siteNameList){
         this.siteNameList = siteNameList;
     }
+
+    /**
+     * 获取 站点名称
+     * @return siteNameNotList
+     */
+    public List<String> getSiteNameNotList(){
+        return this.siteNameNotList;
+    }
+
     /**
-    * 获取 开始 部门ID
-    * @return deptIdStart
-    */
+     * 设置 站点名称
+     * @param siteNameNotList
+     */
+    public void setSiteNameNotList(List<String> siteNameNotList){
+        this.siteNameNotList = siteNameNotList;
+    }
+
+    /**
+     * 获取 开始 部门ID
+     * @return deptIdStart
+     */
     public Long getDeptIdStart(){
         return this.deptIdStart;
     }
 
     /**
-    * 设置 开始 部门ID
-    * @param deptIdStart
-    */
+     * 设置 开始 部门ID
+     * @param deptIdStart
+     */
     public void setDeptIdStart(Long deptIdStart){
         this.deptIdStart = deptIdStart;
     }
 
     /**
-    * 获取 结束 部门ID
-    * @return $deptIdEnd
-    */
+     * 获取 结束 部门ID
+     * @return $deptIdEnd
+     */
     public Long getDeptIdEnd(){
         return this.deptIdEnd;
     }
 
     /**
-    * 设置 结束 部门ID
-    * @param deptIdEnd
-    */
+     * 设置 结束 部门ID
+     * @param deptIdEnd
+     */
     public void setDeptIdEnd(Long deptIdEnd){
         this.deptIdEnd = deptIdEnd;
     }
 
     /**
-    * 获取 增加 部门ID
-    * @return deptIdIncrement
-    */
+     * 获取 增加 部门ID
+     * @return deptIdIncrement
+     */
     public Long getDeptIdIncrement(){
         return this.deptIdIncrement;
     }
 
     /**
-    * 设置 增加 部门ID
-    * @param deptIdIncrement
-    */
+     * 设置 增加 部门ID
+     * @param deptIdIncrement
+     */
     public void setDeptIdIncrement(Long deptIdIncrement){
         this.deptIdIncrement = deptIdIncrement;
     }
 
     /**
-    * 获取 部门ID
-    * @return deptIdList
-    */
+     * 获取 部门ID
+     * @return deptIdList
+     */
     public List<Long> getDeptIdList(){
         return this.deptIdList;
     }
 
     /**
-    * 设置 部门ID
-    * @param deptIdList
-    */
+     * 设置 部门ID
+     * @param deptIdList
+     */
     public void setDeptIdList(List<Long> deptIdList){
         this.deptIdList = deptIdList;
     }
 
     /**
-    * 获取 部门名称
-    * @return deptNameList
-    */
+     * 获取 部门ID
+     * @return deptIdNotList
+     */
+    public List<Long> getDeptIdNotList(){
+        return this.deptIdNotList;
+    }
+
+    /**
+     * 设置 部门ID
+     * @param deptIdNotList
+     */
+    public void setDeptIdNotList(List<Long> deptIdNotList){
+        this.deptIdNotList = deptIdNotList;
+    }
+
+
+    /**
+     * 获取 部门名称
+     * @return deptNameList
+     */
     public List<String> getDeptNameList(){
         return this.deptNameList;
     }
 
     /**
-    * 设置 部门名称
-    * @param deptNameList
-    */
+     * 设置 部门名称
+     * @param deptNameList
+     */
     public void setDeptNameList(List<String> deptNameList){
         this.deptNameList = deptNameList;
     }
+
+    /**
+     * 获取 部门名称
+     * @return deptNameNotList
+     */
+    public List<String> getDeptNameNotList(){
+        return this.deptNameNotList;
+    }
+
     /**
-    * 获取 窗口名称
-    * @return nameList
-    */
+     * 设置 部门名称
+     * @param deptNameNotList
+     */
+    public void setDeptNameNotList(List<String> deptNameNotList){
+        this.deptNameNotList = deptNameNotList;
+    }
+
+    /**
+     * 获取 窗口名称
+     * @return nameList
+     */
     public List<String> getNameList(){
         return this.nameList;
     }
 
     /**
-    * 设置 窗口名称
-    * @param nameList
-    */
+     * 设置 窗口名称
+     * @param nameList
+     */
     public void setNameList(List<String> nameList){
         this.nameList = nameList;
     }
+
     /**
-    * 获取 英语窗口名
-    * @return englishNameList
-    */
+     * 获取 窗口名称
+     * @return nameNotList
+     */
+    public List<String> getNameNotList(){
+        return this.nameNotList;
+    }
+
+    /**
+     * 设置 窗口名称
+     * @param nameNotList
+     */
+    public void setNameNotList(List<String> nameNotList){
+        this.nameNotList = nameNotList;
+    }
+
+    /**
+     * 获取 英语窗口名
+     * @return englishNameList
+     */
     public List<String> getEnglishNameList(){
         return this.englishNameList;
     }
 
     /**
-    * 设置 英语窗口名
-    * @param englishNameList
-    */
+     * 设置 英语窗口名
+     * @param englishNameList
+     */
     public void setEnglishNameList(List<String> englishNameList){
         this.englishNameList = englishNameList;
     }
+
+    /**
+     * 获取 英语窗口名
+     * @return englishNameNotList
+     */
+    public List<String> getEnglishNameNotList(){
+        return this.englishNameNotList;
+    }
+
+    /**
+     * 设置 英语窗口名
+     * @param englishNameNotList
+     */
+    public void setEnglishNameNotList(List<String> englishNameNotList){
+        this.englishNameNotList = englishNameNotList;
+    }
+
     /**
-    * 获取 区域
-    * @return regionList
-    */
+     * 获取 区域
+     * @return regionList
+     */
     public List<String> getRegionList(){
         return this.regionList;
     }
 
     /**
-    * 设置 区域
-    * @param regionList
-    */
+     * 设置 区域
+     * @param regionList
+     */
     public void setRegionList(List<String> regionList){
         this.regionList = regionList;
     }
+
+    /**
+     * 获取 区域
+     * @return regionNotList
+     */
+    public List<String> getRegionNotList(){
+        return this.regionNotList;
+    }
+
     /**
-    * 获取 英语区域
-    * @return englishRegionList
-    */
+     * 设置 区域
+     * @param regionNotList
+     */
+    public void setRegionNotList(List<String> regionNotList){
+        this.regionNotList = regionNotList;
+    }
+
+    /**
+     * 获取 英语区域
+     * @return englishRegionList
+     */
     public List<String> getEnglishRegionList(){
         return this.englishRegionList;
     }
 
     /**
-    * 设置 英语区域
-    * @param englishRegionList
-    */
+     * 设置 英语区域
+     * @param englishRegionList
+     */
     public void setEnglishRegionList(List<String> englishRegionList){
         this.englishRegionList = englishRegionList;
     }
+
+    /**
+     * 获取 英语区域
+     * @return englishRegionNotList
+     */
+    public List<String> getEnglishRegionNotList(){
+        return this.englishRegionNotList;
+    }
+
     /**
-    * 获取 窗口编号
-    * @return fromnumList
-    */
+     * 设置 英语区域
+     * @param englishRegionNotList
+     */
+    public void setEnglishRegionNotList(List<String> englishRegionNotList){
+        this.englishRegionNotList = englishRegionNotList;
+    }
+
+    /**
+     * 获取 窗口编号
+     * @return fromnumList
+     */
     public List<String> getFromnumList(){
         return this.fromnumList;
     }
 
     /**
-    * 设置 窗口编号
-    * @param fromnumList
-    */
+     * 设置 窗口编号
+     * @param fromnumList
+     */
     public void setFromnumList(List<String> fromnumList){
         this.fromnumList = fromnumList;
     }
+
+    /**
+     * 获取 窗口编号
+     * @return fromnumNotList
+     */
+    public List<String> getFromnumNotList(){
+        return this.fromnumNotList;
+    }
+
     /**
-    * 获取 开始 红旗窗口 (1.是，0.否)
-    * @return hongqiStart
-    */
+     * 设置 窗口编号
+     * @param fromnumNotList
+     */
+    public void setFromnumNotList(List<String> fromnumNotList){
+        this.fromnumNotList = fromnumNotList;
+    }
+
+    /**
+     * 获取 开始 红旗窗口 (1.是，0.否)
+     * @return hongqiStart
+     */
     public Integer getHongqiStart(){
         return this.hongqiStart;
     }
 
     /**
-    * 设置 开始 红旗窗口 (1.是，0.否)
-    * @param hongqiStart
-    */
+     * 设置 开始 红旗窗口 (1.是，0.否)
+     * @param hongqiStart
+     */
     public void setHongqiStart(Integer hongqiStart){
         this.hongqiStart = hongqiStart;
     }
 
     /**
-    * 获取 结束 红旗窗口 (1.是，0.否)
-    * @return $hongqiEnd
-    */
+     * 获取 结束 红旗窗口 (1.是，0.否)
+     * @return $hongqiEnd
+     */
     public Integer getHongqiEnd(){
         return this.hongqiEnd;
     }
 
     /**
-    * 设置 结束 红旗窗口 (1.是，0.否)
-    * @param hongqiEnd
-    */
+     * 设置 结束 红旗窗口 (1.是，0.否)
+     * @param hongqiEnd
+     */
     public void setHongqiEnd(Integer hongqiEnd){
         this.hongqiEnd = hongqiEnd;
     }
 
     /**
-    * 获取 增加 红旗窗口 (1.是，0.否)
-    * @return hongqiIncrement
-    */
+     * 获取 增加 红旗窗口 (1.是，0.否)
+     * @return hongqiIncrement
+     */
     public Integer getHongqiIncrement(){
         return this.hongqiIncrement;
     }
 
     /**
-    * 设置 增加 红旗窗口 (1.是，0.否)
-    * @param hongqiIncrement
-    */
+     * 设置 增加 红旗窗口 (1.是，0.否)
+     * @param hongqiIncrement
+     */
     public void setHongqiIncrement(Integer hongqiIncrement){
         this.hongqiIncrement = hongqiIncrement;
     }
 
     /**
-    * 获取 红旗窗口 (1.是，0.否)
-    * @return hongqiList
-    */
+     * 获取 红旗窗口 (1.是，0.否)
+     * @return hongqiList
+     */
     public List<Integer> getHongqiList(){
         return this.hongqiList;
     }
 
     /**
-    * 设置 红旗窗口 (1.是，0.否)
-    * @param hongqiList
-    */
+     * 设置 红旗窗口 (1.是，0.否)
+     * @param hongqiList
+     */
     public void setHongqiList(List<Integer> hongqiList){
         this.hongqiList = hongqiList;
     }
 
     /**
-    * 获取 备注
-    * @return summaryList
-    */
+     * 获取 红旗窗口 (1.是，0.否)
+     * @return hongqiNotList
+     */
+    public List<Integer> getHongqiNotList(){
+        return this.hongqiNotList;
+    }
+
+    /**
+     * 设置 红旗窗口 (1.是，0.否)
+     * @param hongqiNotList
+     */
+    public void setHongqiNotList(List<Integer> hongqiNotList){
+        this.hongqiNotList = hongqiNotList;
+    }
+
+
+    /**
+     * 获取 开始 无人值守(1.是，)
+     * @return dutyStart
+     */
+    public Integer getDutyStart(){
+        return this.dutyStart;
+    }
+
+    /**
+     * 设置 开始 无人值守(1.是，)
+     * @param dutyStart
+     */
+    public void setDutyStart(Integer dutyStart){
+        this.dutyStart = dutyStart;
+    }
+
+    /**
+     * 获取 结束 无人值守(1.是，)
+     * @return $dutyEnd
+     */
+    public Integer getDutyEnd(){
+        return this.dutyEnd;
+    }
+
+    /**
+     * 设置 结束 无人值守(1.是，)
+     * @param dutyEnd
+     */
+    public void setDutyEnd(Integer dutyEnd){
+        this.dutyEnd = dutyEnd;
+    }
+
+    /**
+     * 获取 增加 无人值守(1.是，)
+     * @return dutyIncrement
+     */
+    public Integer getDutyIncrement(){
+        return this.dutyIncrement;
+    }
+
+    /**
+     * 设置 增加 无人值守(1.是，)
+     * @param dutyIncrement
+     */
+    public void setDutyIncrement(Integer dutyIncrement){
+        this.dutyIncrement = dutyIncrement;
+    }
+
+    /**
+     * 获取 无人值守(1.是，)
+     * @return dutyList
+     */
+    public List<Integer> getDutyList(){
+        return this.dutyList;
+    }
+
+    /**
+     * 设置 无人值守(1.是，)
+     * @param dutyList
+     */
+    public void setDutyList(List<Integer> dutyList){
+        this.dutyList = dutyList;
+    }
+
+    /**
+     * 获取 无人值守(1.是，)
+     * @return dutyNotList
+     */
+    public List<Integer> getDutyNotList(){
+        return this.dutyNotList;
+    }
+
+    /**
+     * 设置 无人值守(1.是，)
+     * @param dutyNotList
+     */
+    public void setDutyNotList(List<Integer> dutyNotList){
+        this.dutyNotList = dutyNotList;
+    }
+
+
+    /**
+     * 获取 显示内容
+     * @return dutyContentList
+     */
+    public List<String> getDutyContentList(){
+        return this.dutyContentList;
+    }
+
+    /**
+     * 设置 显示内容
+     * @param dutyContentList
+     */
+    public void setDutyContentList(List<String> dutyContentList){
+        this.dutyContentList = dutyContentList;
+    }
+
+    /**
+     * 获取 显示内容
+     * @return dutyContentNotList
+     */
+    public List<String> getDutyContentNotList(){
+        return this.dutyContentNotList;
+    }
+
+    /**
+     * 设置 显示内容
+     * @param dutyContentNotList
+     */
+    public void setDutyContentNotList(List<String> dutyContentNotList){
+        this.dutyContentNotList = dutyContentNotList;
+    }
+
+    /**
+     * 获取 显示英文
+     * @return dutyEnglishList
+     */
+    public List<String> getDutyEnglishList(){
+        return this.dutyEnglishList;
+    }
+
+    /**
+     * 设置 显示英文
+     * @param dutyEnglishList
+     */
+    public void setDutyEnglishList(List<String> dutyEnglishList){
+        this.dutyEnglishList = dutyEnglishList;
+    }
+
+    /**
+     * 获取 显示英文
+     * @return dutyEnglishNotList
+     */
+    public List<String> getDutyEnglishNotList(){
+        return this.dutyEnglishNotList;
+    }
+
+    /**
+     * 设置 显示英文
+     * @param dutyEnglishNotList
+     */
+    public void setDutyEnglishNotList(List<String> dutyEnglishNotList){
+        this.dutyEnglishNotList = dutyEnglishNotList;
+    }
+
+    /**
+     * 获取 备注
+     * @return summaryList
+     */
     public List<String> getSummaryList(){
         return this.summaryList;
     }
 
     /**
-    * 设置 备注
-    * @param summaryList
-    */
+     * 设置 备注
+     * @param summaryList
+     */
     public void setSummaryList(List<String> summaryList){
         this.summaryList = summaryList;
     }
+
+    /**
+     * 获取 备注
+     * @return summaryNotList
+     */
+    public List<String> getSummaryNotList(){
+        return this.summaryNotList;
+    }
+
+    /**
+     * 设置 备注
+     * @param summaryNotList
+     */
+    public void setSummaryNotList(List<String> summaryNotList){
+        this.summaryNotList = summaryNotList;
+    }
+
     /**
-    * 获取 开始 楼栋
-    * @return buildingStart
-    */
+     * 获取 开始 楼栋
+     * @return buildingStart
+     */
     public Integer getBuildingStart(){
         return this.buildingStart;
     }
 
     /**
-    * 设置 开始 楼栋
-    * @param buildingStart
-    */
+     * 设置 开始 楼栋
+     * @param buildingStart
+     */
     public void setBuildingStart(Integer buildingStart){
         this.buildingStart = buildingStart;
     }
 
     /**
-    * 获取 结束 楼栋
-    * @return $buildingEnd
-    */
+     * 获取 结束 楼栋
+     * @return $buildingEnd
+     */
     public Integer getBuildingEnd(){
         return this.buildingEnd;
     }
 
     /**
-    * 设置 结束 楼栋
-    * @param buildingEnd
-    */
+     * 设置 结束 楼栋
+     * @param buildingEnd
+     */
     public void setBuildingEnd(Integer buildingEnd){
         this.buildingEnd = buildingEnd;
     }
 
     /**
-    * 获取 增加 楼栋
-    * @return buildingIncrement
-    */
+     * 获取 增加 楼栋
+     * @return buildingIncrement
+     */
     public Integer getBuildingIncrement(){
         return this.buildingIncrement;
     }
 
     /**
-    * 设置 增加 楼栋
-    * @param buildingIncrement
-    */
+     * 设置 增加 楼栋
+     * @param buildingIncrement
+     */
     public void setBuildingIncrement(Integer buildingIncrement){
         this.buildingIncrement = buildingIncrement;
     }
 
     /**
-    * 获取 楼栋
-    * @return buildingList
-    */
+     * 获取 楼栋
+     * @return buildingList
+     */
     public List<Integer> getBuildingList(){
         return this.buildingList;
     }
 
     /**
-    * 设置 楼栋
-    * @param buildingList
-    */
+     * 设置 楼栋
+     * @param buildingList
+     */
     public void setBuildingList(List<Integer> buildingList){
         this.buildingList = buildingList;
     }
 
     /**
-    * 获取 开始 楼层
-    * @return levelStart
-    */
+     * 获取 楼栋
+     * @return buildingNotList
+     */
+    public List<Integer> getBuildingNotList(){
+        return this.buildingNotList;
+    }
+
+    /**
+     * 设置 楼栋
+     * @param buildingNotList
+     */
+    public void setBuildingNotList(List<Integer> buildingNotList){
+        this.buildingNotList = buildingNotList;
+    }
+
+
+    /**
+     * 获取 开始 楼层
+     * @return levelStart
+     */
     public Integer getLevelStart(){
         return this.levelStart;
     }
 
     /**
-    * 设置 开始 楼层
-    * @param levelStart
-    */
+     * 设置 开始 楼层
+     * @param levelStart
+     */
     public void setLevelStart(Integer levelStart){
         this.levelStart = levelStart;
     }
 
     /**
-    * 获取 结束 楼层
-    * @return $levelEnd
-    */
+     * 获取 结束 楼层
+     * @return $levelEnd
+     */
     public Integer getLevelEnd(){
         return this.levelEnd;
     }
 
     /**
-    * 设置 结束 楼层
-    * @param levelEnd
-    */
+     * 设置 结束 楼层
+     * @param levelEnd
+     */
     public void setLevelEnd(Integer levelEnd){
         this.levelEnd = levelEnd;
     }
 
     /**
-    * 获取 增加 楼层
-    * @return levelIncrement
-    */
+     * 获取 增加 楼层
+     * @return levelIncrement
+     */
     public Integer getLevelIncrement(){
         return this.levelIncrement;
     }
 
     /**
-    * 设置 增加 楼层
-    * @param levelIncrement
-    */
+     * 设置 增加 楼层
+     * @param levelIncrement
+     */
     public void setLevelIncrement(Integer levelIncrement){
         this.levelIncrement = levelIncrement;
     }
 
     /**
-    * 获取 楼层
-    * @return levelList
-    */
+     * 获取 楼层
+     * @return levelList
+     */
     public List<Integer> getLevelList(){
         return this.levelList;
     }
 
     /**
-    * 设置 楼层
-    * @param levelList
-    */
+     * 设置 楼层
+     * @param levelList
+     */
     public void setLevelList(List<Integer> levelList){
         this.levelList = levelList;
     }
 
     /**
-    * 获取 开始 创建时间
-    * @return createTimeStart
-    */
+     * 获取 楼层
+     * @return levelNotList
+     */
+    public List<Integer> getLevelNotList(){
+        return this.levelNotList;
+    }
+
+    /**
+     * 设置 楼层
+     * @param levelNotList
+     */
+    public void setLevelNotList(List<Integer> levelNotList){
+        this.levelNotList = levelNotList;
+    }
+
+
+    /**
+     * 获取 开始 创建时间
+     * @return createTimeStart
+     */
     public String getCreateTimeStart(){
         return this.createTimeStart;
     }
 
     /**
-    * 设置 开始 创建时间
-    * @param createTimeStart
-    */
+     * 设置 开始 创建时间
+     * @param createTimeStart
+     */
     public void setCreateTimeStart(String createTimeStart){
         this.createTimeStart = createTimeStart;
     }
 
     /**
-    * 获取 结束 创建时间
-    * @return createTimeEnd
-    */
+     * 获取 结束 创建时间
+     * @return createTimeEnd
+     */
     public String getCreateTimeEnd(){
         return this.createTimeEnd;
     }
 
     /**
-    * 设置 结束 创建时间
-    * @param createTimeEnd
-    */
+     * 设置 结束 创建时间
+     * @param createTimeEnd
+     */
     public void setCreateTimeEnd(String createTimeEnd){
         this.createTimeEnd = createTimeEnd;
     }
 
     /**
-    * 获取 开始 创建用户
-    * @return createUserIdStart
-    */
+     * 获取 开始 创建用户
+     * @return createUserIdStart
+     */
     public Long getCreateUserIdStart(){
         return this.createUserIdStart;
     }
 
     /**
-    * 设置 开始 创建用户
-    * @param createUserIdStart
-    */
+     * 设置 开始 创建用户
+     * @param createUserIdStart
+     */
     public void setCreateUserIdStart(Long createUserIdStart){
         this.createUserIdStart = createUserIdStart;
     }
 
     /**
-    * 获取 结束 创建用户
-    * @return $createUserIdEnd
-    */
+     * 获取 结束 创建用户
+     * @return $createUserIdEnd
+     */
     public Long getCreateUserIdEnd(){
         return this.createUserIdEnd;
     }
 
     /**
-    * 设置 结束 创建用户
-    * @param createUserIdEnd
-    */
+     * 设置 结束 创建用户
+     * @param createUserIdEnd
+     */
     public void setCreateUserIdEnd(Long createUserIdEnd){
         this.createUserIdEnd = createUserIdEnd;
     }
 
     /**
-    * 获取 增加 创建用户
-    * @return createUserIdIncrement
-    */
+     * 获取 增加 创建用户
+     * @return createUserIdIncrement
+     */
     public Long getCreateUserIdIncrement(){
         return this.createUserIdIncrement;
     }
 
     /**
-    * 设置 增加 创建用户
-    * @param createUserIdIncrement
-    */
+     * 设置 增加 创建用户
+     * @param createUserIdIncrement
+     */
     public void setCreateUserIdIncrement(Long createUserIdIncrement){
         this.createUserIdIncrement = createUserIdIncrement;
     }
 
     /**
-    * 获取 创建用户
-    * @return createUserIdList
-    */
+     * 获取 创建用户
+     * @return createUserIdList
+     */
     public List<Long> getCreateUserIdList(){
         return this.createUserIdList;
     }
 
     /**
-    * 设置 创建用户
-    * @param createUserIdList
-    */
+     * 设置 创建用户
+     * @param createUserIdList
+     */
     public void setCreateUserIdList(List<Long> createUserIdList){
         this.createUserIdList = createUserIdList;
     }
 
     /**
-    * 获取 开始 修改时间
-    * @return updateTimeStart
-    */
+     * 获取 创建用户
+     * @return createUserIdNotList
+     */
+    public List<Long> getCreateUserIdNotList(){
+        return this.createUserIdNotList;
+    }
+
+    /**
+     * 设置 创建用户
+     * @param createUserIdNotList
+     */
+    public void setCreateUserIdNotList(List<Long> createUserIdNotList){
+        this.createUserIdNotList = createUserIdNotList;
+    }
+
+
+    /**
+     * 获取 开始 修改时间
+     * @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;
     }
 
     /**
-    * 设置  序号，主键，自增长
-    * @param id
-    */
+     * 设置  序号，主键，自增长
+     * @param id
+     */
     public WindowQuery id(Long id){
-	    setId(id);
-		return this;
-    }
-	
-	 /**
-    * 设置 开始 序号，主键，自增长
-    * @param idStart
-    */
+        setId(id);
+        return this;
+    }
+
+    /**
+     * 设置 开始 序号，主键，自增长
+     * @param idStart
+     */
     public WindowQuery idStart(Long idStart){
-		this.idStart = idStart;
-		return this;
+        this.idStart = idStart;
+        return this;
     }
 
     /**
-    * 设置 结束 序号，主键，自增长
-    * @param idEnd
-    */
+     * 设置 结束 序号，主键，自增长
+     * @param idEnd
+     */
     public WindowQuery idEnd(Long idEnd){
-		this.idEnd = idEnd;
-		return this;
+        this.idEnd = idEnd;
+        return this;
     }
 
     /**
-    * 设置 增加 序号，主键，自增长
-    * @param idIncrement
-    */
+     * 设置 增加 序号，主键，自增长
+     * @param idIncrement
+     */
     public WindowQuery idIncrement(Long idIncrement){
-		this.idIncrement = idIncrement;
-		return this;
+        this.idIncrement = idIncrement;
+        return this;
     }
 
     /**
-    * 设置 序号，主键，自增长
-    * @param idList
-    */
+     * 设置 序号，主键，自增长
+     * @param idList
+     */
     public WindowQuery idList(List<Long> idList){
         this.idList = idList;
-		return this;
-        }
+        return this;
+    }
 
     /**
-    * 设置  站点ID
-    * @param siteId
-    */
+     * 设置 序号，主键，自增长
+     * @param idNotList
+     */
+    public WindowQuery idNotList(List<Long> idNotList){
+        this.idNotList = idNotList;
+        return this;
+    }
+
+    /**
+     * 设置  站点ID
+     * @param siteId
+     */
     public WindowQuery siteId(Long siteId){
-	    setSiteId(siteId);
-		return this;
-    }
-	
-	 /**
-    * 设置 开始 站点ID
-    * @param siteIdStart
-    */
+        setSiteId(siteId);
+        return this;
+    }
+
+    /**
+     * 设置 开始 站点ID
+     * @param siteIdStart
+     */
     public WindowQuery siteIdStart(Long siteIdStart){
-		this.siteIdStart = siteIdStart;
-		return this;
+        this.siteIdStart = siteIdStart;
+        return this;
     }
 
     /**
-    * 设置 结束 站点ID
-    * @param siteIdEnd
-    */
+     * 设置 结束 站点ID
+     * @param siteIdEnd
+     */
     public WindowQuery siteIdEnd(Long siteIdEnd){
-		this.siteIdEnd = siteIdEnd;
-		return this;
+        this.siteIdEnd = siteIdEnd;
+        return this;
     }
 
     /**
-    * 设置 增加 站点ID
-    * @param siteIdIncrement
-    */
+     * 设置 增加 站点ID
+     * @param siteIdIncrement
+     */
     public WindowQuery siteIdIncrement(Long siteIdIncrement){
-		this.siteIdIncrement = siteIdIncrement;
-		return this;
+        this.siteIdIncrement = siteIdIncrement;
+        return this;
     }
 
     /**
-    * 设置 站点ID
-    * @param siteIdList
-    */
+     * 设置 站点ID
+     * @param siteIdList
+     */
     public WindowQuery siteIdList(List<Long> siteIdList){
         this.siteIdList = siteIdList;
-		return this;
-        }
+        return this;
+    }
+
+    /**
+     * 设置 站点ID
+     * @param siteIdNotList
+     */
+    public WindowQuery siteIdNotList(List<Long> siteIdNotList){
+        this.siteIdNotList = siteIdNotList;
+        return this;
+    }
 
 
-	/**
-    * 设置 站点名称
-    * @param siteName
-    */
+    /**
+     * 设置 站点名称
+     * @param siteName
+     */
     public WindowQuery siteName(String siteName){
         setSiteName(siteName);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 站点名称
-    * @param siteNameList
-    */
+     * 设置 站点名称
+     * @param siteNameList
+     */
     public WindowQuery siteNameList(List<String> siteNameList){
         this.siteNameList = siteNameList;
-		return this;
+        return this;
     }
 
     /**
-    * 设置  部门ID
-    * @param deptId
-    */
+     * 设置  部门ID
+     * @param deptId
+     */
     public WindowQuery deptId(Long deptId){
-	    setDeptId(deptId);
-		return this;
-    }
-	
-	 /**
-    * 设置 开始 部门ID
-    * @param deptIdStart
-    */
+        setDeptId(deptId);
+        return this;
+    }
+
+    /**
+     * 设置 开始 部门ID
+     * @param deptIdStart
+     */
     public WindowQuery deptIdStart(Long deptIdStart){
-		this.deptIdStart = deptIdStart;
-		return this;
+        this.deptIdStart = deptIdStart;
+        return this;
     }
 
     /**
-    * 设置 结束 部门ID
-    * @param deptIdEnd
-    */
+     * 设置 结束 部门ID
+     * @param deptIdEnd
+     */
     public WindowQuery deptIdEnd(Long deptIdEnd){
-		this.deptIdEnd = deptIdEnd;
-		return this;
+        this.deptIdEnd = deptIdEnd;
+        return this;
     }
 
     /**
-    * 设置 增加 部门ID
-    * @param deptIdIncrement
-    */
+     * 设置 增加 部门ID
+     * @param deptIdIncrement
+     */
     public WindowQuery deptIdIncrement(Long deptIdIncrement){
-		this.deptIdIncrement = deptIdIncrement;
-		return this;
+        this.deptIdIncrement = deptIdIncrement;
+        return this;
     }
 
     /**
-    * 设置 部门ID
-    * @param deptIdList
-    */
+     * 设置 部门ID
+     * @param deptIdList
+     */
     public WindowQuery deptIdList(List<Long> deptIdList){
         this.deptIdList = deptIdList;
-		return this;
-        }
+        return this;
+    }
+
+    /**
+     * 设置 部门ID
+     * @param deptIdNotList
+     */
+    public WindowQuery deptIdNotList(List<Long> deptIdNotList){
+        this.deptIdNotList = deptIdNotList;
+        return this;
+    }
 
 
-	/**
-    * 设置 部门名称
-    * @param deptName
-    */
+    /**
+     * 设置 部门名称
+     * @param deptName
+     */
     public WindowQuery deptName(String deptName){
         setDeptName(deptName);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 部门名称
-    * @param deptNameList
-    */
+     * 设置 部门名称
+     * @param deptNameList
+     */
     public WindowQuery deptNameList(List<String> deptNameList){
         this.deptNameList = deptNameList;
-		return this;
+        return this;
     }
 
 
-	/**
-    * 设置 窗口名称
-    * @param name
-    */
+    /**
+     * 设置 窗口名称
+     * @param name
+     */
     public WindowQuery name(String name){
         setName(name);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 窗口名称
-    * @param nameList
-    */
+     * 设置 窗口名称
+     * @param nameList
+     */
     public WindowQuery nameList(List<String> nameList){
         this.nameList = nameList;
-		return this;
+        return this;
     }
 
 
-	/**
-    * 设置 英语窗口名
-    * @param englishName
-    */
+    /**
+     * 设置 英语窗口名
+     * @param englishName
+     */
     public WindowQuery englishName(String englishName){
         setEnglishName(englishName);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 英语窗口名
-    * @param englishNameList
-    */
+     * 设置 英语窗口名
+     * @param englishNameList
+     */
     public WindowQuery englishNameList(List<String> englishNameList){
         this.englishNameList = englishNameList;
-		return this;
+        return this;
     }
 
 
-	/**
-    * 设置 区域
-    * @param region
-    */
+    /**
+     * 设置 区域
+     * @param region
+     */
     public WindowQuery region(String region){
         setRegion(region);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 区域
-    * @param regionList
-    */
+     * 设置 区域
+     * @param regionList
+     */
     public WindowQuery regionList(List<String> regionList){
         this.regionList = regionList;
-		return this;
+        return this;
     }
 
 
-	/**
-    * 设置 英语区域
-    * @param englishRegion
-    */
+    /**
+     * 设置 英语区域
+     * @param englishRegion
+     */
     public WindowQuery englishRegion(String englishRegion){
         setEnglishRegion(englishRegion);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 英语区域
-    * @param englishRegionList
-    */
+     * 设置 英语区域
+     * @param englishRegionList
+     */
     public WindowQuery englishRegionList(List<String> englishRegionList){
         this.englishRegionList = englishRegionList;
-		return this;
+        return this;
     }
 
 
-	/**
-    * 设置 窗口编号
-    * @param fromnum
-    */
+    /**
+     * 设置 窗口编号
+     * @param fromnum
+     */
     public WindowQuery fromnum(String fromnum){
         setFromnum(fromnum);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 窗口编号
-    * @param fromnumList
-    */
+     * 设置 窗口编号
+     * @param fromnumList
+     */
     public WindowQuery fromnumList(List<String> fromnumList){
         this.fromnumList = fromnumList;
-		return this;
+        return this;
     }
 
     /**
-    * 设置  红旗窗口 (1.是，0.否)
-    * @param hongqi
-    */
+     * 设置  红旗窗口 (1.是，0.否)
+     * @param hongqi
+     */
     public WindowQuery hongqi(Integer hongqi){
-	    setHongqi(hongqi);
-		return this;
-    }
-	
-	 /**
-    * 设置 开始 红旗窗口 (1.是，0.否)
-    * @param hongqiStart
-    */
+        setHongqi(hongqi);
+        return this;
+    }
+
+    /**
+     * 设置 开始 红旗窗口 (1.是，0.否)
+     * @param hongqiStart
+     */
     public WindowQuery hongqiStart(Integer hongqiStart){
-		this.hongqiStart = hongqiStart;
-		return this;
+        this.hongqiStart = hongqiStart;
+        return this;
     }
 
     /**
-    * 设置 结束 红旗窗口 (1.是，0.否)
-    * @param hongqiEnd
-    */
+     * 设置 结束 红旗窗口 (1.是，0.否)
+     * @param hongqiEnd
+     */
     public WindowQuery hongqiEnd(Integer hongqiEnd){
-		this.hongqiEnd = hongqiEnd;
-		return this;
+        this.hongqiEnd = hongqiEnd;
+        return this;
     }
 
     /**
-    * 设置 增加 红旗窗口 (1.是，0.否)
-    * @param hongqiIncrement
-    */
+     * 设置 增加 红旗窗口 (1.是，0.否)
+     * @param hongqiIncrement
+     */
     public WindowQuery hongqiIncrement(Integer hongqiIncrement){
-		this.hongqiIncrement = hongqiIncrement;
-		return this;
+        this.hongqiIncrement = hongqiIncrement;
+        return this;
     }
 
     /**
-    * 设置 红旗窗口 (1.是，0.否)
-    * @param hongqiList
-    */
+     * 设置 红旗窗口 (1.是，0.否)
+     * @param hongqiList
+     */
     public WindowQuery hongqiList(List<Integer> hongqiList){
         this.hongqiList = hongqiList;
-		return this;
-        }
+        return this;
+    }
+
+    /**
+     * 设置 红旗窗口 (1.是，0.否)
+     * @param hongqiNotList
+     */
+    public WindowQuery hongqiNotList(List<Integer> hongqiNotList){
+        this.hongqiNotList = hongqiNotList;
+        return this;
+    }
+
+    /**
+     * 设置  无人值守(1.是，)
+     * @param duty
+     */
+    public WindowQuery duty(Integer duty){
+        setDuty(duty);
+        return this;
+    }
+
+    /**
+     * 设置 开始 无人值守(1.是，)
+     * @param dutyStart
+     */
+    public WindowQuery dutyStart(Integer dutyStart){
+        this.dutyStart = dutyStart;
+        return this;
+    }
+
+    /**
+     * 设置 结束 无人值守(1.是，)
+     * @param dutyEnd
+     */
+    public WindowQuery dutyEnd(Integer dutyEnd){
+        this.dutyEnd = dutyEnd;
+        return this;
+    }
+
+    /**
+     * 设置 增加 无人值守(1.是，)
+     * @param dutyIncrement
+     */
+    public WindowQuery dutyIncrement(Integer dutyIncrement){
+        this.dutyIncrement = dutyIncrement;
+        return this;
+    }
+
+    /**
+     * 设置 无人值守(1.是，)
+     * @param dutyList
+     */
+    public WindowQuery dutyList(List<Integer> dutyList){
+        this.dutyList = dutyList;
+        return this;
+    }
+
+    /**
+     * 设置 无人值守(1.是，)
+     * @param dutyNotList
+     */
+    public WindowQuery dutyNotList(List<Integer> dutyNotList){
+        this.dutyNotList = dutyNotList;
+        return this;
+    }
+
 
+    /**
+     * 设置 显示内容
+     * @param dutyContent
+     */
+    public WindowQuery dutyContent(String dutyContent){
+        setDutyContent(dutyContent);
+        return this;
+    }
+
+    /**
+     * 设置 显示内容
+     * @param dutyContentList
+     */
+    public WindowQuery dutyContentList(List<String> dutyContentList){
+        this.dutyContentList = dutyContentList;
+        return this;
+    }
+
+
+    /**
+     * 设置 显示英文
+     * @param dutyEnglish
+     */
+    public WindowQuery dutyEnglish(String dutyEnglish){
+        setDutyEnglish(dutyEnglish);
+        return this;
+    }
 
-	/**
-    * 设置 备注
-    * @param summary
-    */
+    /**
+     * 设置 显示英文
+     * @param dutyEnglishList
+     */
+    public WindowQuery dutyEnglishList(List<String> dutyEnglishList){
+        this.dutyEnglishList = dutyEnglishList;
+        return this;
+    }
+
+
+    /**
+     * 设置 备注
+     * @param summary
+     */
     public WindowQuery summary(String summary){
         setSummary(summary);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 备注
-    * @param summaryList
-    */
+     * 设置 备注
+     * @param summaryList
+     */
     public WindowQuery summaryList(List<String> summaryList){
         this.summaryList = summaryList;
-		return this;
+        return this;
     }
 
     /**
-    * 设置  楼栋
-    * @param building
-    */
+     * 设置  楼栋
+     * @param building
+     */
     public WindowQuery building(Integer building){
-	    setBuilding(building);
-		return this;
-    }
-	
-	 /**
-    * 设置 开始 楼栋
-    * @param buildingStart
-    */
+        setBuilding(building);
+        return this;
+    }
+
+    /**
+     * 设置 开始 楼栋
+     * @param buildingStart
+     */
     public WindowQuery buildingStart(Integer buildingStart){
-		this.buildingStart = buildingStart;
-		return this;
+        this.buildingStart = buildingStart;
+        return this;
     }
 
     /**
-    * 设置 结束 楼栋
-    * @param buildingEnd
-    */
+     * 设置 结束 楼栋
+     * @param buildingEnd
+     */
     public WindowQuery buildingEnd(Integer buildingEnd){
-		this.buildingEnd = buildingEnd;
-		return this;
+        this.buildingEnd = buildingEnd;
+        return this;
     }
 
     /**
-    * 设置 增加 楼栋
-    * @param buildingIncrement
-    */
+     * 设置 增加 楼栋
+     * @param buildingIncrement
+     */
     public WindowQuery buildingIncrement(Integer buildingIncrement){
-		this.buildingIncrement = buildingIncrement;
-		return this;
+        this.buildingIncrement = buildingIncrement;
+        return this;
     }
 
     /**
-    * 设置 楼栋
-    * @param buildingList
-    */
+     * 设置 楼栋
+     * @param buildingList
+     */
     public WindowQuery buildingList(List<Integer> buildingList){
         this.buildingList = buildingList;
-		return this;
-        }
+        return this;
+    }
 
     /**
-    * 设置  楼层
-    * @param level
-    */
+     * 设置 楼栋
+     * @param buildingNotList
+     */
+    public WindowQuery buildingNotList(List<Integer> buildingNotList){
+        this.buildingNotList = buildingNotList;
+        return this;
+    }
+
+    /**
+     * 设置  楼层
+     * @param level
+     */
     public WindowQuery level(Integer level){
-	    setLevel(level);
-		return this;
-    }
-	
-	 /**
-    * 设置 开始 楼层
-    * @param levelStart
-    */
+        setLevel(level);
+        return this;
+    }
+
+    /**
+     * 设置 开始 楼层
+     * @param levelStart
+     */
     public WindowQuery levelStart(Integer levelStart){
-		this.levelStart = levelStart;
-		return this;
+        this.levelStart = levelStart;
+        return this;
     }
 
     /**
-    * 设置 结束 楼层
-    * @param levelEnd
-    */
+     * 设置 结束 楼层
+     * @param levelEnd
+     */
     public WindowQuery levelEnd(Integer levelEnd){
-		this.levelEnd = levelEnd;
-		return this;
+        this.levelEnd = levelEnd;
+        return this;
     }
 
     /**
-    * 设置 增加 楼层
-    * @param levelIncrement
-    */
+     * 设置 增加 楼层
+     * @param levelIncrement
+     */
     public WindowQuery levelIncrement(Integer levelIncrement){
-		this.levelIncrement = levelIncrement;
-		return this;
+        this.levelIncrement = levelIncrement;
+        return this;
     }
 
     /**
-    * 设置 楼层
-    * @param levelList
-    */
+     * 设置 楼层
+     * @param levelList
+     */
     public WindowQuery levelList(List<Integer> levelList){
         this.levelList = levelList;
-		return this;
-        }
+        return this;
+    }
+
+    /**
+     * 设置 楼层
+     * @param levelNotList
+     */
+    public WindowQuery levelNotList(List<Integer> levelNotList){
+        this.levelNotList = levelNotList;
+        return this;
+    }
 
 
     /**
-    * 设置  创建用户
-    * @param createUserId
-    */
+     * 设置  创建用户
+     * @param createUserId
+     */
     public WindowQuery createUserId(Long createUserId){
-	    setCreateUserId(createUserId);
-		return this;
-    }
-	
-	 /**
-    * 设置 开始 创建用户
-    * @param createUserIdStart
-    */
+        setCreateUserId(createUserId);
+        return this;
+    }
+
+    /**
+     * 设置 开始 创建用户
+     * @param createUserIdStart
+     */
     public WindowQuery createUserIdStart(Long createUserIdStart){
-		this.createUserIdStart = createUserIdStart;
-		return this;
+        this.createUserIdStart = createUserIdStart;
+        return this;
     }
 
     /**
-    * 设置 结束 创建用户
-    * @param createUserIdEnd
-    */
+     * 设置 结束 创建用户
+     * @param createUserIdEnd
+     */
     public WindowQuery createUserIdEnd(Long createUserIdEnd){
-		this.createUserIdEnd = createUserIdEnd;
-		return this;
+        this.createUserIdEnd = createUserIdEnd;
+        return this;
     }
 
     /**
-    * 设置 增加 创建用户
-    * @param createUserIdIncrement
-    */
+     * 设置 增加 创建用户
+     * @param createUserIdIncrement
+     */
     public WindowQuery createUserIdIncrement(Long createUserIdIncrement){
-		this.createUserIdIncrement = createUserIdIncrement;
-		return this;
+        this.createUserIdIncrement = createUserIdIncrement;
+        return this;
     }
 
     /**
-    * 设置 创建用户
-    * @param createUserIdList
-    */
+     * 设置 创建用户
+     * @param createUserIdList
+     */
     public WindowQuery createUserIdList(List<Long> createUserIdList){
         this.createUserIdList = createUserIdList;
-		return this;
-        }
+        return this;
+    }
+
+    /**
+     * 设置 创建用户
+     * @param createUserIdNotList
+     */
+    public WindowQuery createUserIdNotList(List<Long> createUserIdNotList){
+        this.createUserIdNotList = createUserIdNotList;
+        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<WindowQuery> 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<WindowQuery> 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<WindowQuery> 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<WindowQuery> andConditionList){
         this.andConditionList = andConditionList;
     }

base-manager/src/main/resources/sqlmap/module/window/WindowMapper.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.window.dao.ibatis.WindowDaoImpl">
 
     <!-- 字段和属性映射 -->
     <resultMap type="WindowEntity" id="WindowEntity-Map">
-            <id  property="id" column="id" />
-            <result property="siteId" column="siteId" />
-            <result property="siteName" column="siteName" />
-            <result property="deptId" column="deptId" />
-            <result property="deptName" column="deptName" />
-            <result property="name" column="name" />
-            <result property="englishName" column="englishName" />
-            <result property="region" column="region" />
-            <result property="englishRegion" column="englishRegion" />
-            <result property="fromnum" column="fromnum" />
-            <result property="hongqi" column="hongqi" />
-            <result property="summary" column="summary" />
-            <result property="building" column="building" />
-            <result property="level" column="level" />
-            <result property="createTime" column="createTime" />
-            <result property="createUserId" column="createUserId" />
-            <result property="updateTime" column="updateTime" />
-            
+        <id  property="id" column="id" />
+        <result property="siteId" column="siteId" />
+        <result property="siteName" column="siteName" />
+        <result property="deptId" column="deptId" />
+        <result property="deptName" column="deptName" />
+        <result property="name" column="name" />
+        <result property="englishName" column="englishName" />
+        <result property="region" column="region" />
+        <result property="englishRegion" column="englishRegion" />
+        <result property="fromnum" column="fromnum" />
+        <result property="hongqi" column="hongqi" />
+        <result property="duty" column="duty" />
+        <result property="dutyContent" column="dutyContent" />
+        <result property="dutyEnglish" column="dutyEnglish" />
+        <result property="summary" column="summary" />
+        <result property="building" column="building" />
+        <result property="level" column="level" />
+        <result property="createTime" column="createTime" />
+        <result property="createUserId" column="createUserId" />
+        <result property="updateTime" column="updateTime" />
+
     </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 as 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 as 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 as siteName,
-                </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('deptId') or colPickMode == 1 and data.containsKey('deptId')))">
-                    a.deptId as deptId,
-                </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('deptName') or colPickMode == 1 and data.containsKey('deptName')))">
-                    a.deptName as deptName,
-                </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('name') or colPickMode == 1 and data.containsKey('name')))">
-                    a.name as name,
-                </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('englishName') or colPickMode == 1 and data.containsKey('englishName')))">
-                    a.englishName as englishName,
-                </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('region') or colPickMode == 1 and data.containsKey('region')))">
-                    a.region as region,
-                </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('englishRegion') or colPickMode == 1 and data.containsKey('englishRegion')))">
-                    a.englishRegion as englishRegion,
-                </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('fromnum') or colPickMode == 1 and data.containsKey('fromnum')))">
-                    a.fromnum as fromnum,
-                </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('hongqi') or colPickMode == 1 and data.containsKey('hongqi')))">
-                    a.hongqi as hongqi,
-                </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('summary') or colPickMode == 1 and data.containsKey('summary')))">
-                    a.summary as summary,
-                </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('building') or colPickMode == 1 and data.containsKey('building')))">
-                    a.building as building,
-                </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('level') or colPickMode == 1 and data.containsKey('level')))">
-                    a.level as level,
-                </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createTime') or colPickMode == 1 and data.containsKey('createTime')))">
-                    a.createTime as 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 as 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 as updateTime,
-                </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('deptId') or colPickMode == 1 and data.containsKey('deptId')))">
+                a.deptId,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('deptName') or colPickMode == 1 and data.containsKey('deptName')))">
+                a.deptName,
+            </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('englishName') or colPickMode == 1 and data.containsKey('englishName')))">
+                a.englishName,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('region') or colPickMode == 1 and data.containsKey('region')))">
+                a.region,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('englishRegion') or colPickMode == 1 and data.containsKey('englishRegion')))">
+                a.englishRegion,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('fromnum') or colPickMode == 1 and data.containsKey('fromnum')))">
+                a.fromnum,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('hongqi') or colPickMode == 1 and data.containsKey('hongqi')))">
+                a.hongqi,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('duty') or colPickMode == 1 and data.containsKey('duty')))">
+                a.duty,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('dutyContent') or colPickMode == 1 and data.containsKey('dutyContent')))">
+                a.dutyContent,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('dutyEnglish') or colPickMode == 1 and data.containsKey('dutyEnglish')))">
+                a.dutyEnglish,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('summary') or colPickMode == 1 and data.containsKey('summary')))">
+                a.summary,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('building') or colPickMode == 1 and data.containsKey('building')))">
+                a.building,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('level') or colPickMode == 1 and data.containsKey('level')))">
+                a.level,
+            </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>
         </trim>
     </sql>
     <!-- 新增 区分主键自增加还是业务插入 -->
     <insert id="insert" parameterType="WindowEntity"  useGeneratedKeys="true" keyProperty="id">
         insert into mortals_sys_window
-        (siteId,siteName,deptId,deptName,name,englishName,region,englishRegion,fromnum,hongqi,summary,building,level,createTime,createUserId,updateTime)
+        (siteId,siteName,deptId,deptName,name,englishName,region,englishRegion,fromnum,hongqi,duty,dutyContent,dutyEnglish,summary,building,level,createTime,createUserId,updateTime)
         VALUES
-        (#{siteId},#{siteName},#{deptId},#{deptName},#{name},#{englishName},#{region},#{englishRegion},#{fromnum},#{hongqi},#{summary},#{building},#{level},#{createTime},#{createUserId},#{updateTime})
+        (#{siteId},#{siteName},#{deptId},#{deptName},#{name},#{englishName},#{region},#{englishRegion},#{fromnum},#{hongqi},#{duty},#{dutyContent},#{dutyEnglish},#{summary},#{building},#{level},#{createTime},#{createUserId},#{updateTime})
     </insert>
 
     <!-- 批量新增 -->
     <insert id="insertBatch" parameterType="paramDto">
         insert into mortals_sys_window
-        (siteId,siteName,deptId,deptName,name,englishName,region,englishRegion,fromnum,hongqi,summary,building,level,createTime,createUserId,updateTime)
+        (siteId,siteName,deptId,deptName,name,englishName,region,englishRegion,fromnum,hongqi,duty,dutyContent,dutyEnglish,summary,building,level,createTime,createUserId,updateTime)
         VALUES
         <foreach collection="data.dataList" item="item" index="index" separator="," >
-            (#{item.siteId},#{item.siteName},#{item.deptId},#{item.deptName},#{item.name},#{item.englishName},#{item.region},#{item.englishRegion},#{item.fromnum},#{item.hongqi},#{item.summary},#{item.building},#{item.level},#{item.createTime},#{item.createUserId},#{item.updateTime})
+            (#{item.siteId},#{item.siteName},#{item.deptId},#{item.deptName},#{item.name},#{item.englishName},#{item.region},#{item.englishRegion},#{item.fromnum},#{item.hongqi},#{item.duty},#{item.dutyContent},#{item.dutyEnglish},#{item.summary},#{item.building},#{item.level},#{item.createTime},#{item.createUserId},#{item.updateTime})
         </foreach>
     </insert>
 
@@ -145,6 +157,18 @@
             <if test="(colPickMode==0 and data.containsKey('hongqiIncrement')) or (colPickMode==1 and !data.containsKey('hongqiIncrement'))">
                 a.hongqi=ifnull(a.hongqi,0) + #{data.hongqiIncrement},
             </if>
+            <if test="(colPickMode==0 and data.containsKey('duty')) or (colPickMode==1 and !data.containsKey('duty'))">
+                a.duty=#{data.duty},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('dutyIncrement')) or (colPickMode==1 and !data.containsKey('dutyIncrement'))">
+                a.duty=ifnull(a.duty,0) + #{data.dutyIncrement},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('dutyContent')) or (colPickMode==1 and !data.containsKey('dutyContent'))">
+                a.dutyContent=#{data.dutyContent},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('dutyEnglish')) or (colPickMode==1 and !data.containsKey('dutyEnglish'))">
+                a.dutyEnglish=#{data.dutyEnglish},
+            </if>
             <if test="(colPickMode==0 and data.containsKey('summary')) or (colPickMode==1 and !data.containsKey('summary'))">
                 a.summary=#{data.summary},
             </if>
@@ -184,148 +208,174 @@
     <update id="updateBatch" parameterType="paramDto">
         update mortals_sys_window 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="deptId=(case" suffix="ELSE deptId end),">
-                            <foreach collection="data.dataList" item="item" index="index" separator="" >
-                                <choose>
-                                    <when test="(colPickMode==0 and item.containsKey('deptId')) or (colPickMode==1 and !item.containsKey('deptId'))">
-                                        when a.id=#{item.id} then #{item.deptId}
-                                    </when>
-                                    <when test="(colPickMode==0 and item.containsKey('deptIdIncrement')) or (colPickMode==1 and !item.containsKey('deptIdIncrement'))">
-                                        when a.id=#{item.id} then ifnull(a.deptId,0) + #{item.deptIdIncrement}
-                                    </when>
-                                </choose>
-                            </foreach>
-                        </trim>
-                <trim prefix="deptName=(case" suffix="ELSE deptName end),">
-                    <foreach collection="data.dataList" item="item" index="index" separator="" >
-                        <if test="(colPickMode==0 and item.containsKey('deptName')) or (colPickMode==1 and !item.containsKey('deptName'))">
-                            when a.id=#{item.id} then #{item.deptName}
-                        </if>
-                    </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="englishName=(case" suffix="ELSE englishName end),">
-                    <foreach collection="data.dataList" item="item" index="index" separator="" >
-                        <if test="(colPickMode==0 and item.containsKey('englishName')) or (colPickMode==1 and !item.containsKey('englishName'))">
-                            when a.id=#{item.id} then #{item.englishName}
-                        </if>
-                    </foreach>
-                </trim>
-                <trim prefix="region=(case" suffix="ELSE region end),">
-                    <foreach collection="data.dataList" item="item" index="index" separator="" >
-                        <if test="(colPickMode==0 and item.containsKey('region')) or (colPickMode==1 and !item.containsKey('region'))">
-                            when a.id=#{item.id} then #{item.region}
-                        </if>
-                    </foreach>
-                </trim>
-                <trim prefix="englishRegion=(case" suffix="ELSE englishRegion end),">
-                    <foreach collection="data.dataList" item="item" index="index" separator="" >
-                        <if test="(colPickMode==0 and item.containsKey('englishRegion')) or (colPickMode==1 and !item.containsKey('englishRegion'))">
-                            when a.id=#{item.id} then #{item.englishRegion}
-                        </if>
-                    </foreach>
-                </trim>
-                <trim prefix="fromnum=(case" suffix="ELSE fromnum end),">
-                    <foreach collection="data.dataList" item="item" index="index" separator="" >
-                        <if test="(colPickMode==0 and item.containsKey('fromnum')) or (colPickMode==1 and !item.containsKey('fromnum'))">
-                            when a.id=#{item.id} then #{item.fromnum}
-                        </if>
-                    </foreach>
-                </trim>
-                        <trim prefix="hongqi=(case" suffix="ELSE hongqi end),">
-                            <foreach collection="data.dataList" item="item" index="index" separator="" >
-                                <choose>
-                                    <when test="(colPickMode==0 and item.containsKey('hongqi')) or (colPickMode==1 and !item.containsKey('hongqi'))">
-                                        when a.id=#{item.id} then #{item.hongqi}
-                                    </when>
-                                    <when test="(colPickMode==0 and item.containsKey('hongqiIncrement')) or (colPickMode==1 and !item.containsKey('hongqiIncrement'))">
-                                        when a.id=#{item.id} then ifnull(a.hongqi,0) + #{item.hongqiIncrement}
-                                    </when>
-                                </choose>
-                            </foreach>
-                        </trim>
-                <trim prefix="summary=(case" suffix="ELSE summary end),">
-                    <foreach collection="data.dataList" item="item" index="index" separator="" >
-                        <if test="(colPickMode==0 and item.containsKey('summary')) or (colPickMode==1 and !item.containsKey('summary'))">
-                            when a.id=#{item.id} then #{item.summary}
-                        </if>
-                    </foreach>
-                </trim>
-                        <trim prefix="building=(case" suffix="ELSE building end),">
-                            <foreach collection="data.dataList" item="item" index="index" separator="" >
-                                <choose>
-                                    <when test="(colPickMode==0 and item.containsKey('building')) or (colPickMode==1 and !item.containsKey('building'))">
-                                        when a.id=#{item.id} then #{item.building}
-                                    </when>
-                                    <when test="(colPickMode==0 and item.containsKey('buildingIncrement')) or (colPickMode==1 and !item.containsKey('buildingIncrement'))">
-                                        when a.id=#{item.id} then ifnull(a.building,0) + #{item.buildingIncrement}
-                                    </when>
-                                </choose>
-                            </foreach>
-                        </trim>
-                        <trim prefix="level=(case" suffix="ELSE level end),">
-                            <foreach collection="data.dataList" item="item" index="index" separator="" >
-                                <choose>
-                                    <when test="(colPickMode==0 and item.containsKey('level')) or (colPickMode==1 and !item.containsKey('level'))">
-                                        when a.id=#{item.id} then #{item.level}
-                                    </when>
-                                    <when test="(colPickMode==0 and item.containsKey('levelIncrement')) or (colPickMode==1 and !item.containsKey('levelIncrement'))">
-                                        when a.id=#{item.id} then ifnull(a.level,0) + #{item.levelIncrement}
-                                    </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="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="deptId=(case" suffix="ELSE deptId end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <choose>
+                        <when test="(colPickMode==0 and item.containsKey('deptId')) or (colPickMode==1 and !item.containsKey('deptId'))">
+                            when a.id=#{item.id} then #{item.deptId}
+                        </when>
+                        <when test="(colPickMode==0 and item.containsKey('deptIdIncrement')) or (colPickMode==1 and !item.containsKey('deptIdIncrement'))">
+                            when a.id=#{item.id} then ifnull(a.deptId,0) + #{item.deptIdIncrement}
+                        </when>
+                    </choose>
+                </foreach>
+            </trim>
+            <trim prefix="deptName=(case" suffix="ELSE deptName end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('deptName')) or (colPickMode==1 and !item.containsKey('deptName'))">
+                        when a.id=#{item.id} then #{item.deptName}
+                    </if>
+                </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="englishName=(case" suffix="ELSE englishName end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('englishName')) or (colPickMode==1 and !item.containsKey('englishName'))">
+                        when a.id=#{item.id} then #{item.englishName}
+                    </if>
+                </foreach>
+            </trim>
+            <trim prefix="region=(case" suffix="ELSE region end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('region')) or (colPickMode==1 and !item.containsKey('region'))">
+                        when a.id=#{item.id} then #{item.region}
+                    </if>
+                </foreach>
+            </trim>
+            <trim prefix="englishRegion=(case" suffix="ELSE englishRegion end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('englishRegion')) or (colPickMode==1 and !item.containsKey('englishRegion'))">
+                        when a.id=#{item.id} then #{item.englishRegion}
+                    </if>
+                </foreach>
+            </trim>
+            <trim prefix="fromnum=(case" suffix="ELSE fromnum end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('fromnum')) or (colPickMode==1 and !item.containsKey('fromnum'))">
+                        when a.id=#{item.id} then #{item.fromnum}
+                    </if>
+                </foreach>
+            </trim>
+            <trim prefix="hongqi=(case" suffix="ELSE hongqi end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <choose>
+                        <when test="(colPickMode==0 and item.containsKey('hongqi')) or (colPickMode==1 and !item.containsKey('hongqi'))">
+                            when a.id=#{item.id} then #{item.hongqi}
+                        </when>
+                        <when test="(colPickMode==0 and item.containsKey('hongqiIncrement')) or (colPickMode==1 and !item.containsKey('hongqiIncrement'))">
+                            when a.id=#{item.id} then ifnull(a.hongqi,0) + #{item.hongqiIncrement}
+                        </when>
+                    </choose>
+                </foreach>
+            </trim>
+            <trim prefix="duty=(case" suffix="ELSE duty end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <choose>
+                        <when test="(colPickMode==0 and item.containsKey('duty')) or (colPickMode==1 and !item.containsKey('duty'))">
+                            when a.id=#{item.id} then #{item.duty}
+                        </when>
+                        <when test="(colPickMode==0 and item.containsKey('dutyIncrement')) or (colPickMode==1 and !item.containsKey('dutyIncrement'))">
+                            when a.id=#{item.id} then ifnull(a.duty,0) + #{item.dutyIncrement}
+                        </when>
+                    </choose>
+                </foreach>
+            </trim>
+            <trim prefix="dutyContent=(case" suffix="ELSE dutyContent end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('dutyContent')) or (colPickMode==1 and !item.containsKey('dutyContent'))">
+                        when a.id=#{item.id} then #{item.dutyContent}
+                    </if>
+                </foreach>
+            </trim>
+            <trim prefix="dutyEnglish=(case" suffix="ELSE dutyEnglish end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('dutyEnglish')) or (colPickMode==1 and !item.containsKey('dutyEnglish'))">
+                        when a.id=#{item.id} then #{item.dutyEnglish}
+                    </if>
+                </foreach>
+            </trim>
+            <trim prefix="summary=(case" suffix="ELSE summary end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('summary')) or (colPickMode==1 and !item.containsKey('summary'))">
+                        when a.id=#{item.id} then #{item.summary}
+                    </if>
+                </foreach>
+            </trim>
+            <trim prefix="building=(case" suffix="ELSE building end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <choose>
+                        <when test="(colPickMode==0 and item.containsKey('building')) or (colPickMode==1 and !item.containsKey('building'))">
+                            when a.id=#{item.id} then #{item.building}
+                        </when>
+                        <when test="(colPickMode==0 and item.containsKey('buildingIncrement')) or (colPickMode==1 and !item.containsKey('buildingIncrement'))">
+                            when a.id=#{item.id} then ifnull(a.building,0) + #{item.buildingIncrement}
+                        </when>
+                    </choose>
+                </foreach>
+            </trim>
+            <trim prefix="level=(case" suffix="ELSE level end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <choose>
+                        <when test="(colPickMode==0 and item.containsKey('level')) or (colPickMode==1 and !item.containsKey('level'))">
+                            when a.id=#{item.id} then #{item.level}
+                        </when>
+                        <when test="(colPickMode==0 and item.containsKey('levelIncrement')) or (colPickMode==1 and !item.containsKey('levelIncrement'))">
+                            when a.id=#{item.id} then ifnull(a.level,0) + #{item.levelIncrement}
+                        </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>
         where id in
         <foreach collection="data.dataList" item="item" index="index" open="(" separator="," close=")">
@@ -349,6 +399,21 @@
             #{item}
         </foreach>
     </delete>
+    <!-- 根据主健列表删除一批，针对单一主健有效 -->
+    <delete id="deleteByKeyList">
+        delete from mortals_sys_window where id in
+        <foreach collection="list" item="item" index="index" open="(" separator="," close=")">
+            #{item}
+        </foreach>
+    </delete>
+
+    <!-- 根据对象列表删除一批，针对单一主健有效 -->
+    <delete id="deleteByEntityList">
+        delete from mortals_sys_window where id in
+        <foreach collection="list" item="item" index="index" open="(" separator="," close=")">
+            #{item.id}
+        </foreach>
+    </delete>
     <!-- 根据paramDto删除一批 -->
     <delete id="deleteByMap" parameterType="paramDto">
         delete a.* from mortals_sys_window as a
@@ -427,401 +492,575 @@
                 ${_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')">
-                ${_conditionType_} a.id in
-                <foreach collection="conditionParamRef.idList" 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')">
+            ${_conditionType_} a.id in
+            <foreach collection="conditionParamRef.idList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('idNotList')">
+            ${_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')">
-                ${_conditionType_} a.siteId in
-                <foreach collection="conditionParamRef.siteIdList" 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')">
+            ${_conditionType_} a.siteId in
+            <foreach collection="conditionParamRef.siteIdList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('siteIdNotList')">
+            ${_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')">
-                ${_conditionType_} a.siteName in
-                <foreach collection="conditionParamRef.siteNameList" 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('deptId')">
-                <if test="conditionParamRef.deptId != null ">
-                    ${_conditionType_} a.deptId = #{${_conditionParam_}.deptId}
-                </if>
-                <if test="conditionParamRef.deptId == null">
-                    ${_conditionType_} a.deptId is null
-                </if>
+            <if test="conditionParamRef.siteName == null">
+                ${_conditionType_} a.siteName is null
             </if>
-            <if test="conditionParamRef.containsKey('deptIdList')">
-                ${_conditionType_} a.deptId in
-                <foreach collection="conditionParamRef.deptIdList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
-            </if>
-            <if test="conditionParamRef.containsKey('deptIdStart') and conditionParamRef.deptIdStart != null">
-                ${_conditionType_} a.deptId <![CDATA[ >= ]]> #{${_conditionParam_}.deptIdStart}
+        </if>
+        <if test="conditionParamRef.containsKey('siteNameList')">
+            ${_conditionType_} a.siteName in
+            <foreach collection="conditionParamRef.siteNameList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('siteNameNotList')">
+            ${_conditionType_} a.siteName not in
+            <foreach collection="conditionParamRef.siteNameNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('deptId')">
+            <if test="conditionParamRef.deptId != null ">
+                ${_conditionType_} a.deptId = #{${_conditionParam_}.deptId}
             </if>
-            <if test="conditionParamRef.containsKey('deptIdEnd') and conditionParamRef.deptIdEnd != null">
-                ${_conditionType_} a.deptId <![CDATA[ <= ]]> #{${_conditionParam_}.deptIdEnd}
+            <if test="conditionParamRef.deptId == null">
+                ${_conditionType_} a.deptId is null
             </if>
+        </if>
+        <if test="conditionParamRef.containsKey('deptIdList')">
+            ${_conditionType_} a.deptId in
+            <foreach collection="conditionParamRef.deptIdList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('deptIdNotList')">
+            ${_conditionType_} a.deptId not in
+            <foreach collection="conditionParamRef.deptIdNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('deptIdStart') and conditionParamRef.deptIdStart != null">
+            ${_conditionType_} a.deptId <![CDATA[ >= ]]> #{${_conditionParam_}.deptIdStart}
+        </if>
+        <if test="conditionParamRef.containsKey('deptIdEnd') and conditionParamRef.deptIdEnd != null">
+            ${_conditionType_} a.deptId <![CDATA[ <= ]]> #{${_conditionParam_}.deptIdEnd}
+        </if>
 
 
-            <if test="conditionParamRef.containsKey('deptName')">
-                <if test="conditionParamRef.deptName != null and conditionParamRef.deptName != ''">
-                    ${_conditionType_} a.deptName like #{${_conditionParam_}.deptName}
-                </if>
-                <if test="conditionParamRef.deptName == null">
-                    ${_conditionType_} a.deptName is null
-                </if>
+        <if test="conditionParamRef.containsKey('deptName')">
+            <if test="conditionParamRef.deptName != null and conditionParamRef.deptName != ''">
+                ${_conditionType_} a.deptName like #{${_conditionParam_}.deptName}
             </if>
-            <if test="conditionParamRef.containsKey('deptNameList')">
-                ${_conditionType_} a.deptName in
-                <foreach collection="conditionParamRef.deptNameList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
+            <if test="conditionParamRef.deptName == null">
+                ${_conditionType_} a.deptName is null
             </if>
+        </if>
+        <if test="conditionParamRef.containsKey('deptNameList')">
+            ${_conditionType_} a.deptName in
+            <foreach collection="conditionParamRef.deptNameList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('deptNameNotList')">
+            ${_conditionType_} a.deptName not in
+            <foreach collection="conditionParamRef.deptNameNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </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')">
-                ${_conditionType_} a.name in
-                <foreach collection="conditionParamRef.nameList" 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')">
+            ${_conditionType_} a.name in
+            <foreach collection="conditionParamRef.nameList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('nameNotList')">
+            ${_conditionType_} a.name not in
+            <foreach collection="conditionParamRef.nameNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
-            <if test="conditionParamRef.containsKey('englishName')">
-                <if test="conditionParamRef.englishName != null and conditionParamRef.englishName != ''">
-                    ${_conditionType_} a.englishName like #{${_conditionParam_}.englishName}
-                </if>
-                <if test="conditionParamRef.englishName == null">
-                    ${_conditionType_} a.englishName is null
-                </if>
+        <if test="conditionParamRef.containsKey('englishName')">
+            <if test="conditionParamRef.englishName != null and conditionParamRef.englishName != ''">
+                ${_conditionType_} a.englishName like #{${_conditionParam_}.englishName}
             </if>
-            <if test="conditionParamRef.containsKey('englishNameList')">
-                ${_conditionType_} a.englishName in
-                <foreach collection="conditionParamRef.englishNameList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
+            <if test="conditionParamRef.englishName == null">
+                ${_conditionType_} a.englishName is null
             </if>
+        </if>
+        <if test="conditionParamRef.containsKey('englishNameList')">
+            ${_conditionType_} a.englishName in
+            <foreach collection="conditionParamRef.englishNameList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('englishNameNotList')">
+            ${_conditionType_} a.englishName not in
+            <foreach collection="conditionParamRef.englishNameNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
-            <if test="conditionParamRef.containsKey('region')">
-                <if test="conditionParamRef.region != null and conditionParamRef.region != ''">
-                    ${_conditionType_} a.region like #{${_conditionParam_}.region}
-                </if>
-                <if test="conditionParamRef.region == null">
-                    ${_conditionType_} a.region is null
-                </if>
+        <if test="conditionParamRef.containsKey('region')">
+            <if test="conditionParamRef.region != null and conditionParamRef.region != ''">
+                ${_conditionType_} a.region like #{${_conditionParam_}.region}
             </if>
-            <if test="conditionParamRef.containsKey('regionList')">
-                ${_conditionType_} a.region in
-                <foreach collection="conditionParamRef.regionList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
+            <if test="conditionParamRef.region == null">
+                ${_conditionType_} a.region is null
             </if>
+        </if>
+        <if test="conditionParamRef.containsKey('regionList')">
+            ${_conditionType_} a.region in
+            <foreach collection="conditionParamRef.regionList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('regionNotList')">
+            ${_conditionType_} a.region not in
+            <foreach collection="conditionParamRef.regionNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
-            <if test="conditionParamRef.containsKey('englishRegion')">
-                <if test="conditionParamRef.englishRegion != null and conditionParamRef.englishRegion != ''">
-                    ${_conditionType_} a.englishRegion like #{${_conditionParam_}.englishRegion}
-                </if>
-                <if test="conditionParamRef.englishRegion == null">
-                    ${_conditionType_} a.englishRegion is null
-                </if>
+        <if test="conditionParamRef.containsKey('englishRegion')">
+            <if test="conditionParamRef.englishRegion != null and conditionParamRef.englishRegion != ''">
+                ${_conditionType_} a.englishRegion like #{${_conditionParam_}.englishRegion}
             </if>
-            <if test="conditionParamRef.containsKey('englishRegionList')">
-                ${_conditionType_} a.englishRegion in
-                <foreach collection="conditionParamRef.englishRegionList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
+            <if test="conditionParamRef.englishRegion == null">
+                ${_conditionType_} a.englishRegion is null
             </if>
+        </if>
+        <if test="conditionParamRef.containsKey('englishRegionList')">
+            ${_conditionType_} a.englishRegion in
+            <foreach collection="conditionParamRef.englishRegionList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('englishRegionNotList')">
+            ${_conditionType_} a.englishRegion not in
+            <foreach collection="conditionParamRef.englishRegionNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
-            <if test="conditionParamRef.containsKey('fromnum')">
-                <if test="conditionParamRef.fromnum != null and conditionParamRef.fromnum != ''">
-                    ${_conditionType_} a.fromnum like #{${_conditionParam_}.fromnum}
-                </if>
-                <if test="conditionParamRef.fromnum == null">
-                    ${_conditionType_} a.fromnum is null
-                </if>
+        <if test="conditionParamRef.containsKey('fromnum')">
+            <if test="conditionParamRef.fromnum != null and conditionParamRef.fromnum != ''">
+                ${_conditionType_} a.fromnum like #{${_conditionParam_}.fromnum}
             </if>
-            <if test="conditionParamRef.containsKey('fromnumList')">
-                ${_conditionType_} a.fromnum in
-                <foreach collection="conditionParamRef.fromnumList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
+            <if test="conditionParamRef.fromnum == null">
+                ${_conditionType_} a.fromnum is null
             </if>
-            <if test="conditionParamRef.containsKey('hongqi')">
-                <if test="conditionParamRef.hongqi != null ">
-                    ${_conditionType_} a.hongqi = #{${_conditionParam_}.hongqi}
-                </if>
-                <if test="conditionParamRef.hongqi == null">
-                    ${_conditionType_} a.hongqi is null
-                </if>
+        </if>
+        <if test="conditionParamRef.containsKey('fromnumList')">
+            ${_conditionType_} a.fromnum in
+            <foreach collection="conditionParamRef.fromnumList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('fromnumNotList')">
+            ${_conditionType_} a.fromnum not in
+            <foreach collection="conditionParamRef.fromnumNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('hongqi')">
+            <if test="conditionParamRef.hongqi != null ">
+                ${_conditionType_} a.hongqi = #{${_conditionParam_}.hongqi}
             </if>
-            <if test="conditionParamRef.containsKey('hongqiList')">
-                ${_conditionType_} a.hongqi in
-                <foreach collection="conditionParamRef.hongqiList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
+            <if test="conditionParamRef.hongqi == null">
+                ${_conditionType_} a.hongqi is null
             </if>
-            <if test="conditionParamRef.containsKey('hongqiStart') and conditionParamRef.hongqiStart != null">
-                ${_conditionType_} a.hongqi <![CDATA[ >= ]]> #{${_conditionParam_}.hongqiStart}
+        </if>
+        <if test="conditionParamRef.containsKey('hongqiList')">
+            ${_conditionType_} a.hongqi in
+            <foreach collection="conditionParamRef.hongqiList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('hongqiNotList')">
+            ${_conditionType_} a.hongqi not in
+            <foreach collection="conditionParamRef.hongqiNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('hongqiStart') and conditionParamRef.hongqiStart != null">
+            ${_conditionType_} a.hongqi <![CDATA[ >= ]]> #{${_conditionParam_}.hongqiStart}
+        </if>
+        <if test="conditionParamRef.containsKey('hongqiEnd') and conditionParamRef.hongqiEnd != null">
+            ${_conditionType_} a.hongqi <![CDATA[ <= ]]> #{${_conditionParam_}.hongqiEnd}
+        </if>
+
+        <if test="conditionParamRef.containsKey('duty')">
+            <if test="conditionParamRef.duty != null ">
+                ${_conditionType_} a.duty = #{${_conditionParam_}.duty}
             </if>
-            <if test="conditionParamRef.containsKey('hongqiEnd') and conditionParamRef.hongqiEnd != null">
-                ${_conditionType_} a.hongqi <![CDATA[ <= ]]> #{${_conditionParam_}.hongqiEnd}
+            <if test="conditionParamRef.duty == null">
+                ${_conditionType_} a.duty is null
             </if>
+        </if>
+        <if test="conditionParamRef.containsKey('dutyList')">
+            ${_conditionType_} a.duty in
+            <foreach collection="conditionParamRef.dutyList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('dutyNotList')">
+            ${_conditionType_} a.duty not in
+            <foreach collection="conditionParamRef.dutyNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('dutyStart') and conditionParamRef.dutyStart != null">
+            ${_conditionType_} a.duty <![CDATA[ >= ]]> #{${_conditionParam_}.dutyStart}
+        </if>
+        <if test="conditionParamRef.containsKey('dutyEnd') and conditionParamRef.dutyEnd != null">
+            ${_conditionType_} a.duty <![CDATA[ <= ]]> #{${_conditionParam_}.dutyEnd}
+        </if>
 
 
-            <if test="conditionParamRef.containsKey('summary')">
-                <if test="conditionParamRef.summary != null and conditionParamRef.summary != ''">
-                    ${_conditionType_} a.summary like #{${_conditionParam_}.summary}
-                </if>
-                <if test="conditionParamRef.summary == null">
-                    ${_conditionType_} a.summary is null
-                </if>
+        <if test="conditionParamRef.containsKey('dutyContent')">
+            <if test="conditionParamRef.dutyContent != null and conditionParamRef.dutyContent != ''">
+                ${_conditionType_} a.dutyContent like #{${_conditionParam_}.dutyContent}
             </if>
-            <if test="conditionParamRef.containsKey('summaryList')">
-                ${_conditionType_} a.summary in
-                <foreach collection="conditionParamRef.summaryList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
+            <if test="conditionParamRef.dutyContent == null">
+                ${_conditionType_} a.dutyContent is null
             </if>
-            <if test="conditionParamRef.containsKey('building')">
-                <if test="conditionParamRef.building != null ">
-                    ${_conditionType_} a.building = #{${_conditionParam_}.building}
-                </if>
-                <if test="conditionParamRef.building == null">
-                    ${_conditionType_} a.building is null
-                </if>
-            </if>
-            <if test="conditionParamRef.containsKey('buildingList')">
-                ${_conditionType_} a.building in
-                <foreach collection="conditionParamRef.buildingList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
-            </if>
-            <if test="conditionParamRef.containsKey('buildingStart') and conditionParamRef.buildingStart != null">
-                ${_conditionType_} a.building <![CDATA[ >= ]]> #{${_conditionParam_}.buildingStart}
+        </if>
+        <if test="conditionParamRef.containsKey('dutyContentList')">
+            ${_conditionType_} a.dutyContent in
+            <foreach collection="conditionParamRef.dutyContentList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('dutyContentNotList')">
+            ${_conditionType_} a.dutyContent not in
+            <foreach collection="conditionParamRef.dutyContentNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+
+        <if test="conditionParamRef.containsKey('dutyEnglish')">
+            <if test="conditionParamRef.dutyEnglish != null and conditionParamRef.dutyEnglish != ''">
+                ${_conditionType_} a.dutyEnglish like #{${_conditionParam_}.dutyEnglish}
             </if>
-            <if test="conditionParamRef.containsKey('buildingEnd') and conditionParamRef.buildingEnd != null">
-                ${_conditionType_} a.building <![CDATA[ <= ]]> #{${_conditionParam_}.buildingEnd}
+            <if test="conditionParamRef.dutyEnglish == null">
+                ${_conditionType_} a.dutyEnglish is null
             </if>
+        </if>
+        <if test="conditionParamRef.containsKey('dutyEnglishList')">
+            ${_conditionType_} a.dutyEnglish in
+            <foreach collection="conditionParamRef.dutyEnglishList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('dutyEnglishNotList')">
+            ${_conditionType_} a.dutyEnglish not in
+            <foreach collection="conditionParamRef.dutyEnglishNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
-            <if test="conditionParamRef.containsKey('level')">
-                <if test="conditionParamRef.level != null ">
-                    ${_conditionType_} a.level = #{${_conditionParam_}.level}
-                </if>
-                <if test="conditionParamRef.level == null">
-                    ${_conditionType_} a.level is null
-                </if>
+        <if test="conditionParamRef.containsKey('summary')">
+            <if test="conditionParamRef.summary != null and conditionParamRef.summary != ''">
+                ${_conditionType_} a.summary like #{${_conditionParam_}.summary}
             </if>
-            <if test="conditionParamRef.containsKey('levelList')">
-                ${_conditionType_} a.level in
-                <foreach collection="conditionParamRef.levelList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
+            <if test="conditionParamRef.summary == null">
+                ${_conditionType_} a.summary is null
             </if>
-            <if test="conditionParamRef.containsKey('levelStart') and conditionParamRef.levelStart != null">
-                ${_conditionType_} a.level <![CDATA[ >= ]]> #{${_conditionParam_}.levelStart}
+        </if>
+        <if test="conditionParamRef.containsKey('summaryList')">
+            ${_conditionType_} a.summary in
+            <foreach collection="conditionParamRef.summaryList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('summaryNotList')">
+            ${_conditionType_} a.summary not in
+            <foreach collection="conditionParamRef.summaryNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('building')">
+            <if test="conditionParamRef.building != null ">
+                ${_conditionType_} a.building = #{${_conditionParam_}.building}
             </if>
-            <if test="conditionParamRef.containsKey('levelEnd') and conditionParamRef.levelEnd != null">
-                ${_conditionType_} a.level <![CDATA[ <= ]]> #{${_conditionParam_}.levelEnd}
+            <if test="conditionParamRef.building == null">
+                ${_conditionType_} a.building is null
             </if>
+        </if>
+        <if test="conditionParamRef.containsKey('buildingList')">
+            ${_conditionType_} a.building in
+            <foreach collection="conditionParamRef.buildingList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('buildingNotList')">
+            ${_conditionType_} a.building not in
+            <foreach collection="conditionParamRef.buildingNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('buildingStart') and conditionParamRef.buildingStart != null">
+            ${_conditionType_} a.building <![CDATA[ >= ]]> #{${_conditionParam_}.buildingStart}
+        </if>
+        <if test="conditionParamRef.containsKey('buildingEnd') and conditionParamRef.buildingEnd != null">
+            ${_conditionType_} a.building <![CDATA[ <= ]]> #{${_conditionParam_}.buildingEnd}
+        </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('level')">
+            <if test="conditionParamRef.level != null ">
+                ${_conditionType_} a.level = #{${_conditionParam_}.level}
             </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.level == null">
+                ${_conditionType_} a.level 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('createUserId')">
-                <if test="conditionParamRef.createUserId != null ">
-                    ${_conditionType_} a.createUserId = #{${_conditionParam_}.createUserId}
-                </if>
-                <if test="conditionParamRef.createUserId == null">
-                    ${_conditionType_} a.createUserId is null
-                </if>
+        </if>
+        <if test="conditionParamRef.containsKey('levelList')">
+            ${_conditionType_} a.level in
+            <foreach collection="conditionParamRef.levelList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('levelNotList')">
+            ${_conditionType_} a.level not in
+            <foreach collection="conditionParamRef.levelNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('levelStart') and conditionParamRef.levelStart != null">
+            ${_conditionType_} a.level <![CDATA[ >= ]]> #{${_conditionParam_}.levelStart}
+        </if>
+        <if test="conditionParamRef.containsKey('levelEnd') and conditionParamRef.levelEnd != null">
+            ${_conditionType_} a.level <![CDATA[ <= ]]> #{${_conditionParam_}.levelEnd}
+        </if>
+
+
+        <if test="conditionParamRef.containsKey('createTime')">
+            <if test="conditionParamRef.createTime != null ">
+                ${_conditionType_} a.createTime = #{${_conditionParam_}.createTime}
             </if>
-            <if test="conditionParamRef.containsKey('createUserIdList')">
-                ${_conditionType_} a.createUserId in
-                <foreach collection="conditionParamRef.createUserIdList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
+            <if test="conditionParamRef.createTime == null">
+                ${_conditionType_} a.createTime is null
             </if>
-            <if test="conditionParamRef.containsKey('createUserIdStart') and conditionParamRef.createUserIdStart != null">
-                ${_conditionType_} a.createUserId <![CDATA[ >= ]]> #{${_conditionParam_}.createUserIdStart}
+        </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('createUserIdEnd') and conditionParamRef.createUserIdEnd != null">
-                ${_conditionType_} a.createUserId <![CDATA[ <= ]]> #{${_conditionParam_}.createUserIdEnd}
+            <if test="conditionParamRef.createUserId == null">
+                ${_conditionType_} a.createUserId is null
             </if>
+        </if>
+        <if test="conditionParamRef.containsKey('createUserIdList')">
+            ${_conditionType_} a.createUserId in
+            <foreach collection="conditionParamRef.createUserIdList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('createUserIdNotList')">
+            ${_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.updateTime == null">
-                    ${_conditionType_} a.updateTime is null
-                </if>
-            </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.containsKey('updateTime')">
+            <if test="conditionParamRef.updateTime != null ">
+                ${_conditionType_} a.updateTime = #{${_conditionParam_}.updateTime}
             </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 test="conditionParamRef.updateTime == null">
+                ${_conditionType_} a.updateTime is null
             </if>
+        </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>
     </sql>
     <sql id="_orderCols_">
         <if test="orderColList != null and !orderColList.isEmpty()">
             order by
             <trim suffixOverrides=","  suffix="">
                 <foreach collection="orderColList" open="" close="" index="index" item="item" separator=",">
-                     ${item.colName} ${item.sortKind}
+                    ${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('deptId')">
-                        a.deptId
-                        <if test='orderCol.deptId != null and "DESC".equalsIgnoreCase(orderCol.deptId)'>DESC</if>
-                        ,
-                    </if>
-                    <if test="orderCol.containsKey('deptName')">
-                        a.deptName
-                        <if test='orderCol.deptName != null and "DESC".equalsIgnoreCase(orderCol.deptName)'>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('englishName')">
-                        a.englishName
-                        <if test='orderCol.englishName != null and "DESC".equalsIgnoreCase(orderCol.englishName)'>DESC</if>
-                        ,
-                    </if>
-                    <if test="orderCol.containsKey('region')">
-                        a.region
-                        <if test='orderCol.region != null and "DESC".equalsIgnoreCase(orderCol.region)'>DESC</if>
-                        ,
-                    </if>
-                    <if test="orderCol.containsKey('englishRegion')">
-                        a.englishRegion
-                        <if test='orderCol.englishRegion != null and "DESC".equalsIgnoreCase(orderCol.englishRegion)'>DESC</if>
-                        ,
-                    </if>
-                    <if test="orderCol.containsKey('fromnum')">
-                        a.fromnum
-                        <if test='orderCol.fromnum != null and "DESC".equalsIgnoreCase(orderCol.fromnum)'>DESC</if>
-                        ,
-                    </if>
-                    <if test="orderCol.containsKey('hongqi')">
-                        a.hongqi
-                        <if test='orderCol.hongqi != null and "DESC".equalsIgnoreCase(orderCol.hongqi)'>DESC</if>
-                        ,
-                    </if>
-                    <if test="orderCol.containsKey('summary')">
-                        a.summary
-                        <if test='orderCol.summary != null and "DESC".equalsIgnoreCase(orderCol.summary)'>DESC</if>
-                        ,
-                    </if>
-                    <if test="orderCol.containsKey('building')">
-                        a.building
-                        <if test='orderCol.building != null and "DESC".equalsIgnoreCase(orderCol.building)'>DESC</if>
-                        ,
-                    </if>
-                    <if test="orderCol.containsKey('level')">
-                        a.level
-                        <if test='orderCol.level != null and "DESC".equalsIgnoreCase(orderCol.level)'>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('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('deptId')">
+                    a.deptId
+                    <if test='orderCol.deptId != null and "DESC".equalsIgnoreCase(orderCol.deptId)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('deptName')">
+                    a.deptName
+                    <if test='orderCol.deptName != null and "DESC".equalsIgnoreCase(orderCol.deptName)'>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('englishName')">
+                    a.englishName
+                    <if test='orderCol.englishName != null and "DESC".equalsIgnoreCase(orderCol.englishName)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('region')">
+                    a.region
+                    <if test='orderCol.region != null and "DESC".equalsIgnoreCase(orderCol.region)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('englishRegion')">
+                    a.englishRegion
+                    <if test='orderCol.englishRegion != null and "DESC".equalsIgnoreCase(orderCol.englishRegion)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('fromnum')">
+                    a.fromnum
+                    <if test='orderCol.fromnum != null and "DESC".equalsIgnoreCase(orderCol.fromnum)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('hongqi')">
+                    a.hongqi
+                    <if test='orderCol.hongqi != null and "DESC".equalsIgnoreCase(orderCol.hongqi)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('duty')">
+                    a.duty
+                    <if test='orderCol.duty != null and "DESC".equalsIgnoreCase(orderCol.duty)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('dutyContent')">
+                    a.dutyContent
+                    <if test='orderCol.dutyContent != null and "DESC".equalsIgnoreCase(orderCol.dutyContent)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('dutyEnglish')">
+                    a.dutyEnglish
+                    <if test='orderCol.dutyEnglish != null and "DESC".equalsIgnoreCase(orderCol.dutyEnglish)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('summary')">
+                    a.summary
+                    <if test='orderCol.summary != null and "DESC".equalsIgnoreCase(orderCol.summary)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('building')">
+                    a.building
+                    <if test='orderCol.building != null and "DESC".equalsIgnoreCase(orderCol.building)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('level')">
+                    a.level
+                    <if test='orderCol.level != null and "DESC".equalsIgnoreCase(orderCol.level)'>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>
             </trim>
         </if>
     </sql>

base-manager/src/test/java/com/mortals/httpclient/window/WindowController.http

@@ -4,9 +4,11 @@ POST {{baseUrl}}/window/list
 Content-Type: application/json
 
 {
-   "siteId":8,
+   "siteId":1,
     "page":1,
-    "size":10
+    "size":10,
+  "name": "",
+  "fromnum": "1E%"
 }