添加窗口大厅站点选项

base-manager/db/add.sql

@@ -20,7 +20,6 @@ ALTER TABLE mortals_sys_workman ADD COLUMN  `operatorId` varchar (128) default "
 
 
 
-
 -- ----------------------------
 2023-3-28
 -- ----------------------------
@@ -211,3 +210,11 @@ ALTER TABLE mortals_sys_app_info_field ADD COLUMN  `serviceApiParams` varchar(10
 
 ALTER TABLE mortals_sys_app_info_templete_field ADD COLUMN  `serviceApi` varchar(255)   default ''   COMMENT '事件服务接口请求地址';
 ALTER TABLE mortals_sys_app_info_templete_field ADD COLUMN  `serviceApiParams` varchar(1024) default ''     COMMENT '事件服务接口请求参数';
+
+
+
+-- ----------------------------
+2023-10-17
+-- ----------------------------
+
+ALTER TABLE mortals_sys_window_hall ADD COLUMN  `siteId` bigint(20) default '1'     COMMENT '站点Id';

base-manager/src/main/java/com/mortals/xhx/base/system/user/model/UserEntityExt.java

@@ -38,7 +38,9 @@ public class UserEntityExt extends BaseEntityLong {
 
     private List<ModelEntity> modleList;
 
-
-
+    /**
+     * 所属区域code,多个逗号分隔
+     */
+    private String areaCodes;
 
 }
\ No newline at end of file

base-manager/src/main/java/com/mortals/xhx/common/utils/SyncTreeSiteThread.java

@@ -43,14 +43,8 @@ public class SyncTreeSiteThread implements Runnable {
                 Context contextTemp = new Context();
                 contextTemp.setUser(userEntity);
                 siteService.setSiteTree(siteTreeSelects, contextTemp);
-                if(userEntity.getId()==2065L){
-
-                    log.info("2065===>{}",JSON.toJSONString(userEntity));
-                }
-
             }
         }
-       // log.info("刷新用户站点树=》userID:{} siteIds:{} siteTree:{}",context.getUser().getId(),context.getUser().getSiteIds(), JSON.toJSONString(siteService.getSiteTree(context)));
     }
 
 }

base-manager/src/main/java/com/mortals/xhx/module/area/service/AreaService.java

@@ -55,6 +55,7 @@ public interface AreaService extends ICRUDCacheService<AreaEntity,Long> {
 
 
 
+
     /**
      * 获取当前节点所有子节点
      * @param rootId

base-manager/src/main/java/com/mortals/xhx/module/area/service/impl/AreaServiceImpl.java

@@ -186,6 +186,7 @@ public class AreaServiceImpl extends AbstractCRUDCacheServiceImpl<AreaDao, AreaE
         return collect;
     }
 
+
     @Override
     public List<AreaTreeSelect> getListByRootId(String rootId, Context context) {
         if (ObjectUtils.isEmpty(rootId)) {

base-manager/src/main/java/com/mortals/xhx/module/area/web/AreaController.java

@@ -15,6 +15,7 @@ import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;
 
+import java.util.Arrays;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -73,6 +74,33 @@ public class AreaController extends BaseCRUDJsonBodyMappingController<AreaServic
     }
 
 
+    /**
+     * 获取站点下拉树列表
+     */
+    @PostMapping("authAreaTree")
+    public String authAreaTree() {
+        Map<String, Object> model = new HashMap<>();
+        JSONObject ret = new JSONObject();
+        String busiDesc = "查询" + this.getModuleDesc();
+        int code = VALUE_RESULT_SUCCESS;
+        try {
+            List<String> areaCodeList = Arrays.asList(this.getContext().getUser().getAreaCodes().split(","));
+            AreaQuery areaQuery = new AreaQuery();
+            areaQuery.setAreaCodeList(areaCodeList);
+            List<AreaEntity> list = this.service.find(areaQuery);
+            List<AreaTreeSelect> treeSelects = this.service.buildAreaTreeSelect(list);
+            model.put(KEY_RESULT_DATA, treeSelects);
+            recordSysLog(request, busiDesc + " 【成功】");
+        } catch (Exception e) {
+            code = VALUE_RESULT_FAILURE;
+            this.doException(request, busiDesc, model, e);
+        }
+        ret.put(KEY_RESULT_DATA, model);
+        ret.put(KEY_RESULT_CODE, code);
+        return ret.toJSONString();
+    }
+
+
     /**
      * 根据parentId查询子信息
      */
@@ -122,5 +150,4 @@ public class AreaController extends BaseCRUDJsonBodyMappingController<AreaServic
         return ret.toJSONString();
     }
 
-
 }
\ No newline at end of file

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

 package com.mortals.xhx.module.window.model;
 import java.util.List;
 import java.util.ArrayList;
+import java.math.BigDecimal;
+import cn.hutool.core.date.DateUtil;
+import java.util.Date;
 import com.fasterxml.jackson.annotation.JsonFormat;
 import com.mortals.framework.annotation.Excel;
 import com.mortals.framework.model.BaseEntityLong;
 import com.mortals.xhx.module.window.model.vo.WindowHallVo;
 import lombok.Data;
 /**
-* 大厅窗口实体对象
-*
-* @author zxfei
-* @date 2023-04-25
-*/
+ * 大厅窗口实体对象
+ *
+ * @author zxfei
+ * @date 2023-10-17
+ */
 @Data
 public class WindowHallEntity extends WindowHallVo {
     private static final long serialVersionUID = 1L;
 
     /**
-    * 窗口ID
-    */
+     * 站点Id
+     */
+    private Long siteId;
+    /**
+     * 窗口ID
+     */
     private Long windowId;
     /**
-    * 窗口名称
-    */
+     * 窗口名称
+     */
     private String windowName;
     /**
-    * 大厅ID
-    */
+     * 大厅ID
+     */
     private Long hallId;
     /**
-    * 大厅名称
-    */
+     * 大厅名称
+     */
     private String hallName;
     /**
-    * 排序
-    */
+     * 排序
+     */
     private Integer sort;
     /**
-    * 备注
-    */
+     * 备注
+     */
     private String remark;
     @Override
     public int hashCode() {
-         return this.getId().hashCode();
+        return this.getId().hashCode();
     }
     @Override
     public boolean equals(Object obj) {
@@ -50,24 +57,19 @@ public class WindowHallEntity extends WindowHallVo {
         if (obj instanceof WindowHallEntity) {
             WindowHallEntity tmp = (WindowHallEntity) obj;
             if (this.getId() == tmp.getId()) {
-                 return true;
+                return true;
             }
         }
         return false;
     }
 
     public void initAttrValue(){
-
-            this.windowId = null;
-
-            this.windowName = "";
-
-            this.hallId = null;
-
-            this.hallName = "";
-
-            this.sort = 0;
-
-            this.remark = "";
+        this.siteId = null;
+        this.windowId = null;
+        this.windowName = "";
+        this.hallId = null;
+        this.hallName = "";
+        this.sort = 0;
+        this.remark = "";
     }
 }
\ No newline at end of file

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

@@ -3,11 +3,11 @@ package com.mortals.xhx.module.window.model;
 import java.util.List;
 import com.mortals.xhx.module.window.model.WindowHallEntity;
 /**
-* 大厅窗口查询对象
-*
-* @author zxfei
-* @date 2023-04-25
-*/
+ * 大厅窗口查询对象
+ *
+ * @author zxfei
+ * @date 2023-10-17
+ */
 public class WindowHallQuery extends WindowHallEntity {
     /** 开始 序号，主键，自增长 */
     private Long idStart;
@@ -24,6 +24,21 @@ public class WindowHallQuery extends WindowHallEntity {
     /** 序号，主键，自增长排除列表 */
     private List <Long> idNotList;
 
+    /** 开始 站点Id */
+    private Long siteIdStart;
+
+    /** 结束 站点Id */
+    private Long siteIdEnd;
+
+    /** 增加 站点Id */
+    private Long siteIdIncrement;
+
+    /** 站点Id列表 */
+    private List <Long> siteIdList;
+
+    /** 站点Id排除列表 */
+    private List <Long> siteIdNotList;
+
     /** 开始 窗口ID */
     private Long windowIdStart;
 
@@ -120,927 +135,1062 @@ public class WindowHallQuery extends WindowHallEntity {
     public WindowHallQuery(){}
 
     /**
-    * 获取 开始 序号，主键，自增长
-    * @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;
     }
 
     /**
-    * 获取 序号，主键，自增长
-    * @return idNotList
-    */
+     * 获取 序号，主键，自增长
+     * @return idNotList
+     */
     public List<Long> getIdNotList(){
         return this.idNotList;
     }
 
     /**
-    * 设置 序号，主键，自增长
-    * @param idNotList
-    */
+     * 设置 序号，主键，自增长
+     * @param idNotList
+     */
     public void setIdNotList(List<Long> idNotList){
         this.idNotList = idNotList;
     }
 
 
     /**
-    * 获取 开始 窗口ID
-    * @return windowIdStart
-    */
+     * 获取 开始 站点Id
+     * @return siteIdStart
+     */
+    public Long getSiteIdStart(){
+        return this.siteIdStart;
+    }
+
+    /**
+     * 设置 开始 站点Id
+     * @param siteIdStart
+     */
+    public void setSiteIdStart(Long siteIdStart){
+        this.siteIdStart = siteIdStart;
+    }
+
+    /**
+     * 获取 结束 站点Id
+     * @return $siteIdEnd
+     */
+    public Long getSiteIdEnd(){
+        return this.siteIdEnd;
+    }
+
+    /**
+     * 设置 结束 站点Id
+     * @param siteIdEnd
+     */
+    public void setSiteIdEnd(Long siteIdEnd){
+        this.siteIdEnd = siteIdEnd;
+    }
+
+    /**
+     * 获取 增加 站点Id
+     * @return siteIdIncrement
+     */
+    public Long getSiteIdIncrement(){
+        return this.siteIdIncrement;
+    }
+
+    /**
+     * 设置 增加 站点Id
+     * @param siteIdIncrement
+     */
+    public void setSiteIdIncrement(Long siteIdIncrement){
+        this.siteIdIncrement = siteIdIncrement;
+    }
+
+    /**
+     * 获取 站点Id
+     * @return siteIdList
+     */
+    public List<Long> getSiteIdList(){
+        return this.siteIdList;
+    }
+
+    /**
+     * 设置 站点Id
+     * @param siteIdList
+     */
+    public void setSiteIdList(List<Long> siteIdList){
+        this.siteIdList = siteIdList;
+    }
+
+    /**
+     * 获取 站点Id
+     * @return siteIdNotList
+     */
+    public List<Long> getSiteIdNotList(){
+        return this.siteIdNotList;
+    }
+
+    /**
+     * 设置 站点Id
+     * @param siteIdNotList
+     */
+    public void setSiteIdNotList(List<Long> siteIdNotList){
+        this.siteIdNotList = siteIdNotList;
+    }
+
+
+    /**
+     * 获取 开始 窗口ID
+     * @return windowIdStart
+     */
     public Long getWindowIdStart(){
         return this.windowIdStart;
     }
 
     /**
-    * 设置 开始 窗口ID
-    * @param windowIdStart
-    */
+     * 设置 开始 窗口ID
+     * @param windowIdStart
+     */
     public void setWindowIdStart(Long windowIdStart){
         this.windowIdStart = windowIdStart;
     }
 
     /**
-    * 获取 结束 窗口ID
-    * @return $windowIdEnd
-    */
+     * 获取 结束 窗口ID
+     * @return $windowIdEnd
+     */
     public Long getWindowIdEnd(){
         return this.windowIdEnd;
     }
 
     /**
-    * 设置 结束 窗口ID
-    * @param windowIdEnd
-    */
+     * 设置 结束 窗口ID
+     * @param windowIdEnd
+     */
     public void setWindowIdEnd(Long windowIdEnd){
         this.windowIdEnd = windowIdEnd;
     }
 
     /**
-    * 获取 增加 窗口ID
-    * @return windowIdIncrement
-    */
+     * 获取 增加 窗口ID
+     * @return windowIdIncrement
+     */
     public Long getWindowIdIncrement(){
         return this.windowIdIncrement;
     }
 
     /**
-    * 设置 增加 窗口ID
-    * @param windowIdIncrement
-    */
+     * 设置 增加 窗口ID
+     * @param windowIdIncrement
+     */
     public void setWindowIdIncrement(Long windowIdIncrement){
         this.windowIdIncrement = windowIdIncrement;
     }
 
     /**
-    * 获取 窗口ID
-    * @return windowIdList
-    */
+     * 获取 窗口ID
+     * @return windowIdList
+     */
     public List<Long> getWindowIdList(){
         return this.windowIdList;
     }
 
     /**
-    * 设置 窗口ID
-    * @param windowIdList
-    */
+     * 设置 窗口ID
+     * @param windowIdList
+     */
     public void setWindowIdList(List<Long> windowIdList){
         this.windowIdList = windowIdList;
     }
 
     /**
-    * 获取 窗口ID
-    * @return windowIdNotList
-    */
+     * 获取 窗口ID
+     * @return windowIdNotList
+     */
     public List<Long> getWindowIdNotList(){
         return this.windowIdNotList;
     }
 
     /**
-    * 设置 窗口ID
-    * @param windowIdNotList
-    */
+     * 设置 窗口ID
+     * @param windowIdNotList
+     */
     public void setWindowIdNotList(List<Long> windowIdNotList){
         this.windowIdNotList = windowIdNotList;
     }
 
 
     /**
-    * 获取 窗口名称
-    * @return windowNameList
-    */
+     * 获取 窗口名称
+     * @return windowNameList
+     */
     public List<String> getWindowNameList(){
         return this.windowNameList;
     }
 
     /**
-    * 设置 窗口名称
-    * @param windowNameList
-    */
+     * 设置 窗口名称
+     * @param windowNameList
+     */
     public void setWindowNameList(List<String> windowNameList){
         this.windowNameList = windowNameList;
     }
 
     /**
-    * 获取 窗口名称
-    * @return windowNameNotList
-    */
+     * 获取 窗口名称
+     * @return windowNameNotList
+     */
     public List<String> getWindowNameNotList(){
         return this.windowNameNotList;
     }
 
     /**
-    * 设置 窗口名称
-    * @param windowNameNotList
-    */
+     * 设置 窗口名称
+     * @param windowNameNotList
+     */
     public void setWindowNameNotList(List<String> windowNameNotList){
         this.windowNameNotList = windowNameNotList;
     }
 
     /**
-    * 获取 开始 大厅ID
-    * @return hallIdStart
-    */
+     * 获取 开始 大厅ID
+     * @return hallIdStart
+     */
     public Long getHallIdStart(){
         return this.hallIdStart;
     }
 
     /**
-    * 设置 开始 大厅ID
-    * @param hallIdStart
-    */
+     * 设置 开始 大厅ID
+     * @param hallIdStart
+     */
     public void setHallIdStart(Long hallIdStart){
         this.hallIdStart = hallIdStart;
     }
 
     /**
-    * 获取 结束 大厅ID
-    * @return $hallIdEnd
-    */
+     * 获取 结束 大厅ID
+     * @return $hallIdEnd
+     */
     public Long getHallIdEnd(){
         return this.hallIdEnd;
     }
 
     /**
-    * 设置 结束 大厅ID
-    * @param hallIdEnd
-    */
+     * 设置 结束 大厅ID
+     * @param hallIdEnd
+     */
     public void setHallIdEnd(Long hallIdEnd){
         this.hallIdEnd = hallIdEnd;
     }
 
     /**
-    * 获取 增加 大厅ID
-    * @return hallIdIncrement
-    */
+     * 获取 增加 大厅ID
+     * @return hallIdIncrement
+     */
     public Long getHallIdIncrement(){
         return this.hallIdIncrement;
     }
 
     /**
-    * 设置 增加 大厅ID
-    * @param hallIdIncrement
-    */
+     * 设置 增加 大厅ID
+     * @param hallIdIncrement
+     */
     public void setHallIdIncrement(Long hallIdIncrement){
         this.hallIdIncrement = hallIdIncrement;
     }
 
     /**
-    * 获取 大厅ID
-    * @return hallIdList
-    */
+     * 获取 大厅ID
+     * @return hallIdList
+     */
     public List<Long> getHallIdList(){
         return this.hallIdList;
     }
 
     /**
-    * 设置 大厅ID
-    * @param hallIdList
-    */
+     * 设置 大厅ID
+     * @param hallIdList
+     */
     public void setHallIdList(List<Long> hallIdList){
         this.hallIdList = hallIdList;
     }
 
     /**
-    * 获取 大厅ID
-    * @return hallIdNotList
-    */
+     * 获取 大厅ID
+     * @return hallIdNotList
+     */
     public List<Long> getHallIdNotList(){
         return this.hallIdNotList;
     }
 
     /**
-    * 设置 大厅ID
-    * @param hallIdNotList
-    */
+     * 设置 大厅ID
+     * @param hallIdNotList
+     */
     public void setHallIdNotList(List<Long> hallIdNotList){
         this.hallIdNotList = hallIdNotList;
     }
 
 
     /**
-    * 获取 大厅名称
-    * @return hallNameList
-    */
+     * 获取 大厅名称
+     * @return hallNameList
+     */
     public List<String> getHallNameList(){
         return this.hallNameList;
     }
 
     /**
-    * 设置 大厅名称
-    * @param hallNameList
-    */
+     * 设置 大厅名称
+     * @param hallNameList
+     */
     public void setHallNameList(List<String> hallNameList){
         this.hallNameList = hallNameList;
     }
 
     /**
-    * 获取 大厅名称
-    * @return hallNameNotList
-    */
+     * 获取 大厅名称
+     * @return hallNameNotList
+     */
     public List<String> getHallNameNotList(){
         return this.hallNameNotList;
     }
 
     /**
-    * 设置 大厅名称
-    * @param hallNameNotList
-    */
+     * 设置 大厅名称
+     * @param hallNameNotList
+     */
     public void setHallNameNotList(List<String> hallNameNotList){
         this.hallNameNotList = hallNameNotList;
     }
 
     /**
-    * 获取 开始 排序
-    * @return sortStart
-    */
+     * 获取 开始 排序
+     * @return sortStart
+     */
     public Integer getSortStart(){
         return this.sortStart;
     }
 
     /**
-    * 设置 开始 排序
-    * @param sortStart
-    */
+     * 设置 开始 排序
+     * @param sortStart
+     */
     public void setSortStart(Integer sortStart){
         this.sortStart = sortStart;
     }
 
     /**
-    * 获取 结束 排序
-    * @return $sortEnd
-    */
+     * 获取 结束 排序
+     * @return $sortEnd
+     */
     public Integer getSortEnd(){
         return this.sortEnd;
     }
 
     /**
-    * 设置 结束 排序
-    * @param sortEnd
-    */
+     * 设置 结束 排序
+     * @param sortEnd
+     */
     public void setSortEnd(Integer sortEnd){
         this.sortEnd = sortEnd;
     }
 
     /**
-    * 获取 增加 排序
-    * @return sortIncrement
-    */
+     * 获取 增加 排序
+     * @return sortIncrement
+     */
     public Integer getSortIncrement(){
         return this.sortIncrement;
     }
 
     /**
-    * 设置 增加 排序
-    * @param sortIncrement
-    */
+     * 设置 增加 排序
+     * @param sortIncrement
+     */
     public void setSortIncrement(Integer sortIncrement){
         this.sortIncrement = sortIncrement;
     }
 
     /**
-    * 获取 排序
-    * @return sortList
-    */
+     * 获取 排序
+     * @return sortList
+     */
     public List<Integer> getSortList(){
         return this.sortList;
     }
 
     /**
-    * 设置 排序
-    * @param sortList
-    */
+     * 设置 排序
+     * @param sortList
+     */
     public void setSortList(List<Integer> sortList){
         this.sortList = sortList;
     }
 
     /**
-    * 获取 排序
-    * @return sortNotList
-    */
+     * 获取 排序
+     * @return sortNotList
+     */
     public List<Integer> getSortNotList(){
         return this.sortNotList;
     }
 
     /**
-    * 设置 排序
-    * @param sortNotList
-    */
+     * 设置 排序
+     * @param sortNotList
+     */
     public void setSortNotList(List<Integer> sortNotList){
         this.sortNotList = sortNotList;
     }
 
 
     /**
-    * 获取 备注
-    * @return remarkList
-    */
+     * 获取 备注
+     * @return remarkList
+     */
     public List<String> getRemarkList(){
         return this.remarkList;
     }
 
     /**
-    * 设置 备注
-    * @param remarkList
-    */
+     * 设置 备注
+     * @param remarkList
+     */
     public void setRemarkList(List<String> remarkList){
         this.remarkList = remarkList;
     }
 
     /**
-    * 获取 备注
-    * @return remarkNotList
-    */
+     * 获取 备注
+     * @return remarkNotList
+     */
     public List<String> getRemarkNotList(){
         return this.remarkNotList;
     }
 
     /**
-    * 设置 备注
-    * @param remarkNotList
-    */
+     * 设置 备注
+     * @param remarkNotList
+     */
     public void setRemarkNotList(List<String> remarkNotList){
         this.remarkNotList = remarkNotList;
     }
 
     /**
-    * 获取 开始 创建时间
-    * @return createTimeStart
-    */
+     * 获取 开始 创建时间
+     * @return createTimeStart
+     */
     public String getCreateTimeStart(){
         return this.createTimeStart;
     }
 
     /**
-    * 设置 开始 创建时间
-    * @param createTimeStart
-    */
+     * 设置 开始 创建时间
+     * @param createTimeStart
+     */
     public void setCreateTimeStart(String createTimeStart){
         this.createTimeStart = createTimeStart;
     }
 
     /**
-    * 获取 结束 创建时间
-    * @return createTimeEnd
-    */
+     * 获取 结束 创建时间
+     * @return createTimeEnd
+     */
     public String getCreateTimeEnd(){
         return this.createTimeEnd;
     }
 
     /**
-    * 设置 结束 创建时间
-    * @param createTimeEnd
-    */
+     * 设置 结束 创建时间
+     * @param createTimeEnd
+     */
     public void setCreateTimeEnd(String createTimeEnd){
         this.createTimeEnd = createTimeEnd;
     }
 
     /**
-    * 获取 开始 创建用户
-    * @return createUserIdStart
-    */
+     * 获取 开始 创建用户
+     * @return createUserIdStart
+     */
     public Long getCreateUserIdStart(){
         return this.createUserIdStart;
     }
 
     /**
-    * 设置 开始 创建用户
-    * @param createUserIdStart
-    */
+     * 设置 开始 创建用户
+     * @param createUserIdStart
+     */
     public void setCreateUserIdStart(Long createUserIdStart){
         this.createUserIdStart = createUserIdStart;
     }
 
     /**
-    * 获取 结束 创建用户
-    * @return $createUserIdEnd
-    */
+     * 获取 结束 创建用户
+     * @return $createUserIdEnd
+     */
     public Long getCreateUserIdEnd(){
         return this.createUserIdEnd;
     }
 
     /**
-    * 设置 结束 创建用户
-    * @param createUserIdEnd
-    */
+     * 设置 结束 创建用户
+     * @param createUserIdEnd
+     */
     public void setCreateUserIdEnd(Long createUserIdEnd){
         this.createUserIdEnd = createUserIdEnd;
     }
 
     /**
-    * 获取 增加 创建用户
-    * @return createUserIdIncrement
-    */
+     * 获取 增加 创建用户
+     * @return createUserIdIncrement
+     */
     public Long getCreateUserIdIncrement(){
         return this.createUserIdIncrement;
     }
 
     /**
-    * 设置 增加 创建用户
-    * @param createUserIdIncrement
-    */
+     * 设置 增加 创建用户
+     * @param createUserIdIncrement
+     */
     public void setCreateUserIdIncrement(Long createUserIdIncrement){
         this.createUserIdIncrement = createUserIdIncrement;
     }
 
     /**
-    * 获取 创建用户
-    * @return createUserIdList
-    */
+     * 获取 创建用户
+     * @return createUserIdList
+     */
     public List<Long> getCreateUserIdList(){
         return this.createUserIdList;
     }
 
     /**
-    * 设置 创建用户
-    * @param createUserIdList
-    */
+     * 设置 创建用户
+     * @param createUserIdList
+     */
     public void setCreateUserIdList(List<Long> createUserIdList){
         this.createUserIdList = createUserIdList;
     }
 
     /**
-    * 获取 创建用户
-    * @return createUserIdNotList
-    */
+     * 获取 创建用户
+     * @return createUserIdNotList
+     */
     public List<Long> getCreateUserIdNotList(){
         return this.createUserIdNotList;
     }
 
     /**
-    * 设置 创建用户
-    * @param createUserIdNotList
-    */
+     * 设置 创建用户
+     * @param createUserIdNotList
+     */
     public void setCreateUserIdNotList(List<Long> createUserIdNotList){
         this.createUserIdNotList = createUserIdNotList;
     }
 
 
     /**
-    * 获取 开始 修改时间
-    * @return updateTimeStart
-    */
+     * 获取 开始 修改时间
+     * @return updateTimeStart
+     */
     public String getUpdateTimeStart(){
         return this.updateTimeStart;
     }
 
     /**
-    * 设置 开始 修改时间
-    * @param updateTimeStart
-    */
+     * 设置 开始 修改时间
+     * @param updateTimeStart
+     */
     public void setUpdateTimeStart(String updateTimeStart){
         this.updateTimeStart = updateTimeStart;
     }
 
     /**
-    * 获取 结束 修改时间
-    * @return updateTimeEnd
-    */
+     * 获取 结束 修改时间
+     * @return updateTimeEnd
+     */
     public String getUpdateTimeEnd(){
         return this.updateTimeEnd;
     }
 
     /**
-    * 设置 结束 修改时间
-    * @param updateTimeEnd
-    */
+     * 设置 结束 修改时间
+     * @param updateTimeEnd
+     */
     public void setUpdateTimeEnd(String updateTimeEnd){
         this.updateTimeEnd = updateTimeEnd;
     }
 
     /**
-    * 设置  序号，主键，自增长
-    * @param id
-    */
+     * 设置  序号，主键，自增长
+     * @param id
+     */
     public WindowHallQuery id(Long id){
-	    setId(id);
-		return this;
-    }
-	
-	 /**
-    * 设置 开始 序号，主键，自增长
-    * @param idStart
-    */
+        setId(id);
+        return this;
+    }
+
+    /**
+     * 设置 开始 序号，主键，自增长
+     * @param idStart
+     */
     public WindowHallQuery idStart(Long idStart){
-		this.idStart = idStart;
-		return this;
+        this.idStart = idStart;
+        return this;
     }
 
     /**
-    * 设置 结束 序号，主键，自增长
-    * @param idEnd
-    */
+     * 设置 结束 序号，主键，自增长
+     * @param idEnd
+     */
     public WindowHallQuery idEnd(Long idEnd){
-		this.idEnd = idEnd;
-		return this;
+        this.idEnd = idEnd;
+        return this;
     }
 
     /**
-    * 设置 增加 序号，主键，自增长
-    * @param idIncrement
-    */
+     * 设置 增加 序号，主键，自增长
+     * @param idIncrement
+     */
     public WindowHallQuery idIncrement(Long idIncrement){
-		this.idIncrement = idIncrement;
-		return this;
+        this.idIncrement = idIncrement;
+        return this;
     }
 
     /**
-    * 设置 序号，主键，自增长
-    * @param idList
-    */
+     * 设置 序号，主键，自增长
+     * @param idList
+     */
     public WindowHallQuery idList(List<Long> idList){
         this.idList = idList;
-		return this;
-        }
-
-        /**
-        * 设置 序号，主键，自增长
-        * @param idNotList
-        */
-        public WindowHallQuery idNotList(List<Long> idNotList){
+        return this;
+    }
+
+    /**
+     * 设置 序号，主键，自增长
+     * @param idNotList
+     */
+    public WindowHallQuery idNotList(List<Long> idNotList){
         this.idNotList = idNotList;
         return this;
-        }
+    }
+
+    /**
+     * 设置  站点Id
+     * @param siteId
+     */
+    public WindowHallQuery siteId(Long siteId){
+        setSiteId(siteId);
+        return this;
+    }
+
+    /**
+     * 设置 开始 站点Id
+     * @param siteIdStart
+     */
+    public WindowHallQuery siteIdStart(Long siteIdStart){
+        this.siteIdStart = siteIdStart;
+        return this;
+    }
+
+    /**
+     * 设置 结束 站点Id
+     * @param siteIdEnd
+     */
+    public WindowHallQuery siteIdEnd(Long siteIdEnd){
+        this.siteIdEnd = siteIdEnd;
+        return this;
+    }
+
+    /**
+     * 设置 增加 站点Id
+     * @param siteIdIncrement
+     */
+    public WindowHallQuery siteIdIncrement(Long siteIdIncrement){
+        this.siteIdIncrement = siteIdIncrement;
+        return this;
+    }
+
+    /**
+     * 设置 站点Id
+     * @param siteIdList
+     */
+    public WindowHallQuery siteIdList(List<Long> siteIdList){
+        this.siteIdList = siteIdList;
+        return this;
+    }
+
+    /**
+     * 设置 站点Id
+     * @param siteIdNotList
+     */
+    public WindowHallQuery siteIdNotList(List<Long> siteIdNotList){
+        this.siteIdNotList = siteIdNotList;
+        return this;
+    }
 
     /**
-    * 设置  窗口ID
-    * @param windowId
-    */
+     * 设置  窗口ID
+     * @param windowId
+     */
     public WindowHallQuery windowId(Long windowId){
-	    setWindowId(windowId);
-		return this;
-    }
-	
-	 /**
-    * 设置 开始 窗口ID
-    * @param windowIdStart
-    */
+        setWindowId(windowId);
+        return this;
+    }
+
+    /**
+     * 设置 开始 窗口ID
+     * @param windowIdStart
+     */
     public WindowHallQuery windowIdStart(Long windowIdStart){
-		this.windowIdStart = windowIdStart;
-		return this;
+        this.windowIdStart = windowIdStart;
+        return this;
     }
 
     /**
-    * 设置 结束 窗口ID
-    * @param windowIdEnd
-    */
+     * 设置 结束 窗口ID
+     * @param windowIdEnd
+     */
     public WindowHallQuery windowIdEnd(Long windowIdEnd){
-		this.windowIdEnd = windowIdEnd;
-		return this;
+        this.windowIdEnd = windowIdEnd;
+        return this;
     }
 
     /**
-    * 设置 增加 窗口ID
-    * @param windowIdIncrement
-    */
+     * 设置 增加 窗口ID
+     * @param windowIdIncrement
+     */
     public WindowHallQuery windowIdIncrement(Long windowIdIncrement){
-		this.windowIdIncrement = windowIdIncrement;
-		return this;
+        this.windowIdIncrement = windowIdIncrement;
+        return this;
     }
 
     /**
-    * 设置 窗口ID
-    * @param windowIdList
-    */
+     * 设置 窗口ID
+     * @param windowIdList
+     */
     public WindowHallQuery windowIdList(List<Long> windowIdList){
         this.windowIdList = windowIdList;
-		return this;
-        }
-
-        /**
-        * 设置 窗口ID
-        * @param windowIdNotList
-        */
-        public WindowHallQuery windowIdNotList(List<Long> windowIdNotList){
+        return this;
+    }
+
+    /**
+     * 设置 窗口ID
+     * @param windowIdNotList
+     */
+    public WindowHallQuery windowIdNotList(List<Long> windowIdNotList){
         this.windowIdNotList = windowIdNotList;
         return this;
-        }
+    }
 
 
-	/**
-    * 设置 窗口名称
-    * @param windowName
-    */
+    /**
+     * 设置 窗口名称
+     * @param windowName
+     */
     public WindowHallQuery windowName(String windowName){
         setWindowName(windowName);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 窗口名称
-    * @param windowNameList
-    */
+     * 设置 窗口名称
+     * @param windowNameList
+     */
     public WindowHallQuery windowNameList(List<String> windowNameList){
         this.windowNameList = windowNameList;
-		return this;
+        return this;
     }
 
     /**
-    * 设置  大厅ID
-    * @param hallId
-    */
+     * 设置  大厅ID
+     * @param hallId
+     */
     public WindowHallQuery hallId(Long hallId){
-	    setHallId(hallId);
-		return this;
-    }
-	
-	 /**
-    * 设置 开始 大厅ID
-    * @param hallIdStart
-    */
+        setHallId(hallId);
+        return this;
+    }
+
+    /**
+     * 设置 开始 大厅ID
+     * @param hallIdStart
+     */
     public WindowHallQuery hallIdStart(Long hallIdStart){
-		this.hallIdStart = hallIdStart;
-		return this;
+        this.hallIdStart = hallIdStart;
+        return this;
     }
 
     /**
-    * 设置 结束 大厅ID
-    * @param hallIdEnd
-    */
+     * 设置 结束 大厅ID
+     * @param hallIdEnd
+     */
     public WindowHallQuery hallIdEnd(Long hallIdEnd){
-		this.hallIdEnd = hallIdEnd;
-		return this;
+        this.hallIdEnd = hallIdEnd;
+        return this;
     }
 
     /**
-    * 设置 增加 大厅ID
-    * @param hallIdIncrement
-    */
+     * 设置 增加 大厅ID
+     * @param hallIdIncrement
+     */
     public WindowHallQuery hallIdIncrement(Long hallIdIncrement){
-		this.hallIdIncrement = hallIdIncrement;
-		return this;
+        this.hallIdIncrement = hallIdIncrement;
+        return this;
     }
 
     /**
-    * 设置 大厅ID
-    * @param hallIdList
-    */
+     * 设置 大厅ID
+     * @param hallIdList
+     */
     public WindowHallQuery hallIdList(List<Long> hallIdList){
         this.hallIdList = hallIdList;
-		return this;
-        }
-
-        /**
-        * 设置 大厅ID
-        * @param hallIdNotList
-        */
-        public WindowHallQuery hallIdNotList(List<Long> hallIdNotList){
+        return this;
+    }
+
+    /**
+     * 设置 大厅ID
+     * @param hallIdNotList
+     */
+    public WindowHallQuery hallIdNotList(List<Long> hallIdNotList){
         this.hallIdNotList = hallIdNotList;
         return this;
-        }
+    }
 
 
-	/**
-    * 设置 大厅名称
-    * @param hallName
-    */
+    /**
+     * 设置 大厅名称
+     * @param hallName
+     */
     public WindowHallQuery hallName(String hallName){
         setHallName(hallName);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 大厅名称
-    * @param hallNameList
-    */
+     * 设置 大厅名称
+     * @param hallNameList
+     */
     public WindowHallQuery hallNameList(List<String> hallNameList){
         this.hallNameList = hallNameList;
-		return this;
+        return this;
     }
 
     /**
-    * 设置  排序
-    * @param sort
-    */
+     * 设置  排序
+     * @param sort
+     */
     public WindowHallQuery sort(Integer sort){
-	    setSort(sort);
-		return this;
-    }
-	
-	 /**
-    * 设置 开始 排序
-    * @param sortStart
-    */
+        setSort(sort);
+        return this;
+    }
+
+    /**
+     * 设置 开始 排序
+     * @param sortStart
+     */
     public WindowHallQuery sortStart(Integer sortStart){
-		this.sortStart = sortStart;
-		return this;
+        this.sortStart = sortStart;
+        return this;
     }
 
     /**
-    * 设置 结束 排序
-    * @param sortEnd
-    */
+     * 设置 结束 排序
+     * @param sortEnd
+     */
     public WindowHallQuery sortEnd(Integer sortEnd){
-		this.sortEnd = sortEnd;
-		return this;
+        this.sortEnd = sortEnd;
+        return this;
     }
 
     /**
-    * 设置 增加 排序
-    * @param sortIncrement
-    */
+     * 设置 增加 排序
+     * @param sortIncrement
+     */
     public WindowHallQuery sortIncrement(Integer sortIncrement){
-		this.sortIncrement = sortIncrement;
-		return this;
+        this.sortIncrement = sortIncrement;
+        return this;
     }
 
     /**
-    * 设置 排序
-    * @param sortList
-    */
+     * 设置 排序
+     * @param sortList
+     */
     public WindowHallQuery sortList(List<Integer> sortList){
         this.sortList = sortList;
-		return this;
-        }
-
-        /**
-        * 设置 排序
-        * @param sortNotList
-        */
-        public WindowHallQuery sortNotList(List<Integer> sortNotList){
+        return this;
+    }
+
+    /**
+     * 设置 排序
+     * @param sortNotList
+     */
+    public WindowHallQuery sortNotList(List<Integer> sortNotList){
         this.sortNotList = sortNotList;
         return this;
-        }
+    }
 
 
-	/**
-    * 设置 备注
-    * @param remark
-    */
+    /**
+     * 设置 备注
+     * @param remark
+     */
     public WindowHallQuery remark(String remark){
         setRemark(remark);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 备注
-    * @param remarkList
-    */
+     * 设置 备注
+     * @param remarkList
+     */
     public WindowHallQuery remarkList(List<String> remarkList){
         this.remarkList = remarkList;
-		return this;
+        return this;
     }
 
 
     /**
-    * 设置  创建用户
-    * @param createUserId
-    */
+     * 设置  创建用户
+     * @param createUserId
+     */
     public WindowHallQuery createUserId(Long createUserId){
-	    setCreateUserId(createUserId);
-		return this;
-    }
-	
-	 /**
-    * 设置 开始 创建用户
-    * @param createUserIdStart
-    */
+        setCreateUserId(createUserId);
+        return this;
+    }
+
+    /**
+     * 设置 开始 创建用户
+     * @param createUserIdStart
+     */
     public WindowHallQuery createUserIdStart(Long createUserIdStart){
-		this.createUserIdStart = createUserIdStart;
-		return this;
+        this.createUserIdStart = createUserIdStart;
+        return this;
     }
 
     /**
-    * 设置 结束 创建用户
-    * @param createUserIdEnd
-    */
+     * 设置 结束 创建用户
+     * @param createUserIdEnd
+     */
     public WindowHallQuery createUserIdEnd(Long createUserIdEnd){
-		this.createUserIdEnd = createUserIdEnd;
-		return this;
+        this.createUserIdEnd = createUserIdEnd;
+        return this;
     }
 
     /**
-    * 设置 增加 创建用户
-    * @param createUserIdIncrement
-    */
+     * 设置 增加 创建用户
+     * @param createUserIdIncrement
+     */
     public WindowHallQuery createUserIdIncrement(Long createUserIdIncrement){
-		this.createUserIdIncrement = createUserIdIncrement;
-		return this;
+        this.createUserIdIncrement = createUserIdIncrement;
+        return this;
     }
 
     /**
-    * 设置 创建用户
-    * @param createUserIdList
-    */
+     * 设置 创建用户
+     * @param createUserIdList
+     */
     public WindowHallQuery createUserIdList(List<Long> createUserIdList){
         this.createUserIdList = createUserIdList;
-		return this;
-        }
-
-        /**
-        * 设置 创建用户
-        * @param createUserIdNotList
-        */
-        public WindowHallQuery createUserIdNotList(List<Long> createUserIdNotList){
+        return this;
+    }
+
+    /**
+     * 设置 创建用户
+     * @param createUserIdNotList
+     */
+    public WindowHallQuery 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<WindowHallQuery> 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<WindowHallQuery> 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<WindowHallQuery> 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<WindowHallQuery> andConditionList){
         this.andConditionList = andConditionList;
     }

base-manager/src/main/resources/sqlmap/module/window/WindowHallMapper.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.WindowHallDaoImpl">
 
     <!-- 字段和属性映射 -->
     <resultMap type="WindowHallEntity" id="WindowHallEntity-Map">
-            <id  property="id" column="id" />
-            <result property="windowId" column="windowId" />
-            <result property="windowName" column="windowName" />
-            <result property="hallId" column="hallId" />
-            <result property="hallName" column="hallName" />
-            <result property="sort" column="sort" />
-            <result property="remark" column="remark" />
-            <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="windowId" column="windowId" />
+        <result property="windowName" column="windowName" />
+        <result property="hallId" column="hallId" />
+        <result property="hallName" column="hallName" />
+        <result property="sort" column="sort" />
+        <result property="remark" column="remark" />
+        <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,
-                </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('windowId') or colPickMode == 1 and data.containsKey('windowId')))">
-                    a.windowId,
-                </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('windowName') or colPickMode == 1 and data.containsKey('windowName')))">
-                    a.windowName,
-                </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('hallId') or colPickMode == 1 and data.containsKey('hallId')))">
-                    a.hallId,
-                </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('hallName') or colPickMode == 1 and data.containsKey('hallName')))">
-                    a.hallName,
-                </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('sort') or colPickMode == 1 and data.containsKey('sort')))">
-                    a.sort,
-                </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('remark') or colPickMode == 1 and data.containsKey('remark')))">
-                    a.remark,
-                </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createTime') or colPickMode == 1 and data.containsKey('createTime')))">
-                    a.createTime,
-                </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createUserId') or colPickMode == 1 and data.containsKey('createUserId')))">
-                    a.createUserId,
-                </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateTime') or colPickMode == 1 and data.containsKey('updateTime')))">
-                    a.updateTime,
-                </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('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('windowId') or colPickMode == 1 and data.containsKey('windowId')))">
+                a.windowId,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('windowName') or colPickMode == 1 and data.containsKey('windowName')))">
+                a.windowName,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('hallId') or colPickMode == 1 and data.containsKey('hallId')))">
+                a.hallId,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('hallName') or colPickMode == 1 and data.containsKey('hallName')))">
+                a.hallName,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('sort') or colPickMode == 1 and data.containsKey('sort')))">
+                a.sort,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('remark') or colPickMode == 1 and data.containsKey('remark')))">
+                a.remark,
+            </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="WindowHallEntity"  useGeneratedKeys="true" keyProperty="id">
         insert into mortals_sys_window_hall
-        (windowId,windowName,hallId,hallName,sort,remark,createTime,createUserId,updateTime)
+        (siteId,windowId,windowName,hallId,hallName,sort,remark,createTime,createUserId,updateTime)
         VALUES
-        (#{windowId},#{windowName},#{hallId},#{hallName},#{sort},#{remark},#{createTime},#{createUserId},#{updateTime})
+        (#{siteId},#{windowId},#{windowName},#{hallId},#{hallName},#{sort},#{remark},#{createTime},#{createUserId},#{updateTime})
     </insert>
 
     <!-- 批量新增 -->
     <insert id="insertBatch" parameterType="paramDto">
         insert into mortals_sys_window_hall
-        (windowId,windowName,hallId,hallName,sort,remark,createTime,createUserId,updateTime)
+        (siteId,windowId,windowName,hallId,hallName,sort,remark,createTime,createUserId,updateTime)
         VALUES
         <foreach collection="data.dataList" item="item" index="index" separator="," >
-            (#{item.windowId},#{item.windowName},#{item.hallId},#{item.hallName},#{item.sort},#{item.remark},#{item.createTime},#{item.createUserId},#{item.updateTime})
+            (#{item.siteId},#{item.windowId},#{item.windowName},#{item.hallId},#{item.hallName},#{item.sort},#{item.remark},#{item.createTime},#{item.createUserId},#{item.updateTime})
         </foreach>
     </insert>
 
@@ -78,6 +82,12 @@
         update mortals_sys_window_hall as a
         set
         <trim suffixOverrides="," suffix="">
+            <if test="(colPickMode==0 and data.containsKey('siteId')) or (colPickMode==1 and !data.containsKey('siteId'))">
+                a.siteId=#{data.siteId},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('siteIdIncrement')) or (colPickMode==1 and !data.containsKey('siteIdIncrement'))">
+                a.siteId=ifnull(a.siteId,0) + #{data.siteIdIncrement},
+            </if>
             <if test="(colPickMode==0 and data.containsKey('windowId')) or (colPickMode==1 and !data.containsKey('windowId'))">
                 a.windowId=#{data.windowId},
             </if>
@@ -129,89 +139,101 @@
     <update id="updateBatch" parameterType="paramDto">
         update mortals_sys_window_hall as a
         <trim prefix="set" suffixOverrides=",">
-                        <trim prefix="windowId=(case" suffix="ELSE windowId end),">
-                            <foreach collection="data.dataList" item="item" index="index" separator="" >
-                                <choose>
-                                    <when test="(colPickMode==0 and item.containsKey('windowId')) or (colPickMode==1 and !item.containsKey('windowId'))">
-                                        when a.id=#{item.id} then #{item.windowId}
-                                    </when>
-                                    <when test="(colPickMode==0 and item.containsKey('windowIdIncrement')) or (colPickMode==1 and !item.containsKey('windowIdIncrement'))">
-                                        when a.id=#{item.id} then ifnull(a.windowId,0) + #{item.windowIdIncrement}
-                                    </when>
-                                </choose>
-                            </foreach>
-                        </trim>
-                <trim prefix="windowName=(case" suffix="ELSE windowName end),">
-                    <foreach collection="data.dataList" item="item" index="index" separator="" >
-                        <if test="(colPickMode==0 and item.containsKey('windowName')) or (colPickMode==1 and !item.containsKey('windowName'))">
-                            when a.id=#{item.id} then #{item.windowName}
-                        </if>
-                    </foreach>
-                </trim>
-                        <trim prefix="hallId=(case" suffix="ELSE hallId end),">
-                            <foreach collection="data.dataList" item="item" index="index" separator="" >
-                                <choose>
-                                    <when test="(colPickMode==0 and item.containsKey('hallId')) or (colPickMode==1 and !item.containsKey('hallId'))">
-                                        when a.id=#{item.id} then #{item.hallId}
-                                    </when>
-                                    <when test="(colPickMode==0 and item.containsKey('hallIdIncrement')) or (colPickMode==1 and !item.containsKey('hallIdIncrement'))">
-                                        when a.id=#{item.id} then ifnull(a.hallId,0) + #{item.hallIdIncrement}
-                                    </when>
-                                </choose>
-                            </foreach>
-                        </trim>
-                <trim prefix="hallName=(case" suffix="ELSE hallName end),">
-                    <foreach collection="data.dataList" item="item" index="index" separator="" >
-                        <if test="(colPickMode==0 and item.containsKey('hallName')) or (colPickMode==1 and !item.containsKey('hallName'))">
-                            when a.id=#{item.id} then #{item.hallName}
-                        </if>
-                    </foreach>
-                </trim>
-                        <trim prefix="sort=(case" suffix="ELSE sort end),">
-                            <foreach collection="data.dataList" item="item" index="index" separator="" >
-                                <choose>
-                                    <when test="(colPickMode==0 and item.containsKey('sort')) or (colPickMode==1 and !item.containsKey('sort'))">
-                                        when a.id=#{item.id} then #{item.sort}
-                                    </when>
-                                    <when test="(colPickMode==0 and item.containsKey('sortIncrement')) or (colPickMode==1 and !item.containsKey('sortIncrement'))">
-                                        when a.id=#{item.id} then ifnull(a.sort,0) + #{item.sortIncrement}
-                                    </when>
-                                </choose>
-                            </foreach>
-                        </trim>
-                <trim prefix="remark=(case" suffix="ELSE remark end),">
-                    <foreach collection="data.dataList" item="item" index="index" separator="" >
-                        <if test="(colPickMode==0 and item.containsKey('remark')) or (colPickMode==1 and !item.containsKey('remark'))">
-                            when a.id=#{item.id} then #{item.remark}
-                        </if>
-                    </foreach>
-                </trim>
-                <trim prefix="createTime=(case" suffix="ELSE createTime end),">
-                    <foreach collection="data.dataList" item="item" index="index" separator="" >
-                        <if test="(colPickMode==0 and item.containsKey('createTime')) or (colPickMode==1 and !item.containsKey('createTime'))">
-                            when a.id=#{item.id} then #{item.createTime}
-                        </if>
-                    </foreach>
-                </trim>
-                        <trim prefix="createUserId=(case" suffix="ELSE createUserId end),">
-                            <foreach collection="data.dataList" item="item" index="index" separator="" >
-                                <choose>
-                                    <when test="(colPickMode==0 and item.containsKey('createUserId')) or (colPickMode==1 and !item.containsKey('createUserId'))">
-                                        when a.id=#{item.id} then #{item.createUserId}
-                                    </when>
-                                    <when test="(colPickMode==0 and item.containsKey('createUserIdIncrement')) or (colPickMode==1 and !item.containsKey('createUserIdIncrement'))">
-                                        when a.id=#{item.id} then ifnull(a.createUserId,0) + #{item.createUserIdIncrement}
-                                    </when>
-                                </choose>
-                            </foreach>
-                        </trim>
-                <trim prefix="updateTime=(case" suffix="ELSE updateTime end),">
-                    <foreach collection="data.dataList" item="item" index="index" separator="" >
-                        <if test="(colPickMode==0 and item.containsKey('updateTime')) or (colPickMode==1 and !item.containsKey('updateTime'))">
-                            when a.id=#{item.id} then #{item.updateTime}
-                        </if>
-                    </foreach>
-                </trim>
+            <trim prefix="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="windowId=(case" suffix="ELSE windowId end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <choose>
+                        <when test="(colPickMode==0 and item.containsKey('windowId')) or (colPickMode==1 and !item.containsKey('windowId'))">
+                            when a.id=#{item.id} then #{item.windowId}
+                        </when>
+                        <when test="(colPickMode==0 and item.containsKey('windowIdIncrement')) or (colPickMode==1 and !item.containsKey('windowIdIncrement'))">
+                            when a.id=#{item.id} then ifnull(a.windowId,0) + #{item.windowIdIncrement}
+                        </when>
+                    </choose>
+                </foreach>
+            </trim>
+            <trim prefix="windowName=(case" suffix="ELSE windowName end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('windowName')) or (colPickMode==1 and !item.containsKey('windowName'))">
+                        when a.id=#{item.id} then #{item.windowName}
+                    </if>
+                </foreach>
+            </trim>
+            <trim prefix="hallId=(case" suffix="ELSE hallId end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <choose>
+                        <when test="(colPickMode==0 and item.containsKey('hallId')) or (colPickMode==1 and !item.containsKey('hallId'))">
+                            when a.id=#{item.id} then #{item.hallId}
+                        </when>
+                        <when test="(colPickMode==0 and item.containsKey('hallIdIncrement')) or (colPickMode==1 and !item.containsKey('hallIdIncrement'))">
+                            when a.id=#{item.id} then ifnull(a.hallId,0) + #{item.hallIdIncrement}
+                        </when>
+                    </choose>
+                </foreach>
+            </trim>
+            <trim prefix="hallName=(case" suffix="ELSE hallName end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('hallName')) or (colPickMode==1 and !item.containsKey('hallName'))">
+                        when a.id=#{item.id} then #{item.hallName}
+                    </if>
+                </foreach>
+            </trim>
+            <trim prefix="sort=(case" suffix="ELSE sort end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <choose>
+                        <when test="(colPickMode==0 and item.containsKey('sort')) or (colPickMode==1 and !item.containsKey('sort'))">
+                            when a.id=#{item.id} then #{item.sort}
+                        </when>
+                        <when test="(colPickMode==0 and item.containsKey('sortIncrement')) or (colPickMode==1 and !item.containsKey('sortIncrement'))">
+                            when a.id=#{item.id} then ifnull(a.sort,0) + #{item.sortIncrement}
+                        </when>
+                    </choose>
+                </foreach>
+            </trim>
+            <trim prefix="remark=(case" suffix="ELSE remark end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('remark')) or (colPickMode==1 and !item.containsKey('remark'))">
+                        when a.id=#{item.id} then #{item.remark}
+                    </if>
+                </foreach>
+            </trim>
+            <trim prefix="createTime=(case" suffix="ELSE createTime end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('createTime')) or (colPickMode==1 and !item.containsKey('createTime'))">
+                        when a.id=#{item.id} then #{item.createTime}
+                    </if>
+                </foreach>
+            </trim>
+            <trim prefix="createUserId=(case" suffix="ELSE createUserId end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <choose>
+                        <when test="(colPickMode==0 and item.containsKey('createUserId')) or (colPickMode==1 and !item.containsKey('createUserId'))">
+                            when a.id=#{item.id} then #{item.createUserId}
+                        </when>
+                        <when test="(colPickMode==0 and item.containsKey('createUserIdIncrement')) or (colPickMode==1 and !item.containsKey('createUserIdIncrement'))">
+                            when a.id=#{item.id} then ifnull(a.createUserId,0) + #{item.createUserIdIncrement}
+                        </when>
+                    </choose>
+                </foreach>
+            </trim>
+            <trim prefix="updateTime=(case" suffix="ELSE updateTime end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('updateTime')) or (colPickMode==1 and !item.containsKey('updateTime'))">
+                        when a.id=#{item.id} then #{item.updateTime}
+                    </if>
+                </foreach>
+            </trim>
         </trim>
         where id in
         <foreach collection="data.dataList" item="item" index="index" open="(" separator="," close=")">
@@ -328,299 +350,417 @@
                 ${_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 test="conditionParamRef.containsKey('id')">
+            <if test="conditionParamRef.id != null ">
+                ${_conditionType_} a.id = #{${_conditionParam_}.id}
             </if>
-            <if test="conditionParamRef.containsKey('idList') and conditionParamRef.idList.size() > 0">
-                ${_conditionType_} a.id in
-                <foreach collection="conditionParamRef.idList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
+            <if test="conditionParamRef.id == null">
+                ${_conditionType_} a.id is null
             </if>
-            <if test="conditionParamRef.containsKey('idNotList') and conditionParamRef.idNotList.size() > 0">
-                ${_conditionType_} a.id not in
-                <foreach collection="conditionParamRef.idNotList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
-            </if>
-            <if test="conditionParamRef.containsKey('idStart') and conditionParamRef.idStart != null">
-                ${_conditionType_} a.id <![CDATA[ >= ]]> #{${_conditionParam_}.idStart}
+        </if>
+        <if test="conditionParamRef.containsKey('idList') and conditionParamRef.idList.size() > 0">
+            ${_conditionType_} a.id in
+            <foreach collection="conditionParamRef.idList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('idNotList') and conditionParamRef.idNotList.size() > 0">
+            ${_conditionType_} a.id not in
+            <foreach collection="conditionParamRef.idNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('idStart') and conditionParamRef.idStart != null">
+            ${_conditionType_} a.id <![CDATA[ >= ]]> #{${_conditionParam_}.idStart}
+        </if>
+        <if test="conditionParamRef.containsKey('idEnd') and conditionParamRef.idEnd != null">
+            ${_conditionType_} a.id <![CDATA[ <= ]]> #{${_conditionParam_}.idEnd}
+        </if>
+
+        <if test="conditionParamRef.containsKey('siteId')">
+            <if test="conditionParamRef.siteId != null ">
+                ${_conditionType_} a.siteId = #{${_conditionParam_}.siteId}
             </if>
-            <if test="conditionParamRef.containsKey('idEnd') and conditionParamRef.idEnd != null">
-                ${_conditionType_} a.id <![CDATA[ <= ]]> #{${_conditionParam_}.idEnd}
+            <if test="conditionParamRef.siteId == null">
+                ${_conditionType_} a.siteId is null
             </if>
+        </if>
+        <if test="conditionParamRef.containsKey('siteIdList') and conditionParamRef.siteIdList.size() > 0">
+            ${_conditionType_} a.siteId in
+            <foreach collection="conditionParamRef.siteIdList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('siteIdNotList') and conditionParamRef.siteIdNotList.size() > 0">
+            ${_conditionType_} a.siteId not in
+            <foreach collection="conditionParamRef.siteIdNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('siteIdStart') and conditionParamRef.siteIdStart != null">
+            ${_conditionType_} a.siteId <![CDATA[ >= ]]> #{${_conditionParam_}.siteIdStart}
+        </if>
+        <if test="conditionParamRef.containsKey('siteIdEnd') and conditionParamRef.siteIdEnd != null">
+            ${_conditionType_} a.siteId <![CDATA[ <= ]]> #{${_conditionParam_}.siteIdEnd}
+        </if>
 
-            <if test="conditionParamRef.containsKey('windowId')">
-                <if test="conditionParamRef.windowId != null ">
-                    ${_conditionType_} a.windowId = #{${_conditionParam_}.windowId}
-                </if>
-                <if test="conditionParamRef.windowId == null">
-                    ${_conditionType_} a.windowId is null
-                </if>
+        <if test="conditionParamRef.containsKey('windowId')">
+            <if test="conditionParamRef.windowId != null ">
+                ${_conditionType_} a.windowId = #{${_conditionParam_}.windowId}
             </if>
-            <if test="conditionParamRef.containsKey('windowIdList') and conditionParamRef.windowIdList.size() > 0">
-                ${_conditionType_} a.windowId in
-                <foreach collection="conditionParamRef.windowIdList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
+            <if test="conditionParamRef.windowId == null">
+                ${_conditionType_} a.windowId is null
             </if>
-            <if test="conditionParamRef.containsKey('windowIdNotList') and conditionParamRef.windowIdNotList.size() > 0">
-                ${_conditionType_} a.windowId not in
-                <foreach collection="conditionParamRef.windowIdNotList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('windowIdList') and conditionParamRef.windowIdList.size() > 0">
+            ${_conditionType_} a.windowId in
+            <foreach collection="conditionParamRef.windowIdList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('windowIdNotList') and conditionParamRef.windowIdNotList.size() > 0">
+            ${_conditionType_} a.windowId not in
+            <foreach collection="conditionParamRef.windowIdNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('windowIdStart') and conditionParamRef.windowIdStart != null">
+            ${_conditionType_} a.windowId <![CDATA[ >= ]]> #{${_conditionParam_}.windowIdStart}
+        </if>
+        <if test="conditionParamRef.containsKey('windowIdEnd') and conditionParamRef.windowIdEnd != null">
+            ${_conditionType_} a.windowId <![CDATA[ <= ]]> #{${_conditionParam_}.windowIdEnd}
+        </if>
+
+
+        <if test="conditionParamRef.containsKey('windowName')">
+            <if test="conditionParamRef.windowName != null and conditionParamRef.windowName != ''">
+                ${_conditionType_} a.windowName like #{${_conditionParam_}.windowName}
             </if>
-            <if test="conditionParamRef.containsKey('windowIdStart') and conditionParamRef.windowIdStart != null">
-                ${_conditionType_} a.windowId <![CDATA[ >= ]]> #{${_conditionParam_}.windowIdStart}
+            <if test="conditionParamRef.windowName == null">
+                ${_conditionType_} a.windowName is null
             </if>
-            <if test="conditionParamRef.containsKey('windowIdEnd') and conditionParamRef.windowIdEnd != null">
-                ${_conditionType_} a.windowId <![CDATA[ <= ]]> #{${_conditionParam_}.windowIdEnd}
+        </if>
+        <if test="conditionParamRef.containsKey('windowNameList') and conditionParamRef.windowNameList.size() > 0">
+            ${_conditionType_} a.windowName in
+            <foreach collection="conditionParamRef.windowNameList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('windowNameNotList') and conditionParamRef.windowNameNotList.size() > 0">
+            ${_conditionType_} a.windowName not in
+            <foreach collection="conditionParamRef.windowNameNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('hallId')">
+            <if test="conditionParamRef.hallId != null ">
+                ${_conditionType_} a.hallId = #{${_conditionParam_}.hallId}
             </if>
+            <if test="conditionParamRef.hallId == null">
+                ${_conditionType_} a.hallId is null
+            </if>
+        </if>
+        <if test="conditionParamRef.containsKey('hallIdList') and conditionParamRef.hallIdList.size() > 0">
+            ${_conditionType_} a.hallId in
+            <foreach collection="conditionParamRef.hallIdList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('hallIdNotList') and conditionParamRef.hallIdNotList.size() > 0">
+            ${_conditionType_} a.hallId not in
+            <foreach collection="conditionParamRef.hallIdNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('hallIdStart') and conditionParamRef.hallIdStart != null">
+            ${_conditionType_} a.hallId <![CDATA[ >= ]]> #{${_conditionParam_}.hallIdStart}
+        </if>
+        <if test="conditionParamRef.containsKey('hallIdEnd') and conditionParamRef.hallIdEnd != null">
+            ${_conditionType_} a.hallId <![CDATA[ <= ]]> #{${_conditionParam_}.hallIdEnd}
+        </if>
 
 
-            <if test="conditionParamRef.containsKey('windowName')">
-                <if test="conditionParamRef.windowName != null and conditionParamRef.windowName != ''">
-                    ${_conditionType_} a.windowName like #{${_conditionParam_}.windowName}
-                </if>
-                <if test="conditionParamRef.windowName == null">
-                    ${_conditionType_} a.windowName is null
-                </if>
+        <if test="conditionParamRef.containsKey('hallName')">
+            <if test="conditionParamRef.hallName != null and conditionParamRef.hallName != ''">
+                ${_conditionType_} a.hallName like #{${_conditionParam_}.hallName}
             </if>
-            <if test="conditionParamRef.containsKey('windowNameList') and conditionParamRef.windowNameList.size() > 0">
-                ${_conditionType_} a.windowName in
-                <foreach collection="conditionParamRef.windowNameList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
+            <if test="conditionParamRef.hallName == null">
+                ${_conditionType_} a.hallName is null
             </if>
-            <if test="conditionParamRef.containsKey('windowNameNotList') and conditionParamRef.windowNameNotList.size() > 0">
-                ${_conditionType_} a.windowName not in
-                <foreach collection="conditionParamRef.windowNameNotList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('hallNameList') and conditionParamRef.hallNameList.size() > 0">
+            ${_conditionType_} a.hallName in
+            <foreach collection="conditionParamRef.hallNameList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('hallNameNotList') and conditionParamRef.hallNameNotList.size() > 0">
+            ${_conditionType_} a.hallName not in
+            <foreach collection="conditionParamRef.hallNameNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('sort')">
+            <if test="conditionParamRef.sort != null ">
+                ${_conditionType_} a.sort = #{${_conditionParam_}.sort}
             </if>
-            <if test="conditionParamRef.containsKey('hallId')">
-                <if test="conditionParamRef.hallId != null ">
-                    ${_conditionType_} a.hallId = #{${_conditionParam_}.hallId}
-                </if>
-                <if test="conditionParamRef.hallId == null">
-                    ${_conditionType_} a.hallId is null
-                </if>
+            <if test="conditionParamRef.sort == null">
+                ${_conditionType_} a.sort is null
             </if>
-            <if test="conditionParamRef.containsKey('hallIdList') and conditionParamRef.hallIdList.size() > 0">
-                ${_conditionType_} a.hallId in
-                <foreach collection="conditionParamRef.hallIdList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('sortList') and conditionParamRef.sortList.size() > 0">
+            ${_conditionType_} a.sort in
+            <foreach collection="conditionParamRef.sortList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('sortNotList') and conditionParamRef.sortNotList.size() > 0">
+            ${_conditionType_} a.sort not in
+            <foreach collection="conditionParamRef.sortNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('sortStart') and conditionParamRef.sortStart != null">
+            ${_conditionType_} a.sort <![CDATA[ >= ]]> #{${_conditionParam_}.sortStart}
+        </if>
+        <if test="conditionParamRef.containsKey('sortEnd') and conditionParamRef.sortEnd != null">
+            ${_conditionType_} a.sort <![CDATA[ <= ]]> #{${_conditionParam_}.sortEnd}
+        </if>
+
+
+        <if test="conditionParamRef.containsKey('remark')">
+            <if test="conditionParamRef.remark != null and conditionParamRef.remark != ''">
+                ${_conditionType_} a.remark like #{${_conditionParam_}.remark}
             </if>
-            <if test="conditionParamRef.containsKey('hallIdNotList') and conditionParamRef.hallIdNotList.size() > 0">
-                ${_conditionType_} a.hallId not in
-                <foreach collection="conditionParamRef.hallIdNotList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
+            <if test="conditionParamRef.remark == null">
+                ${_conditionType_} a.remark is null
+            </if>
+        </if>
+        <if test="conditionParamRef.containsKey('remarkList') and conditionParamRef.remarkList.size() > 0">
+            ${_conditionType_} a.remark in
+            <foreach collection="conditionParamRef.remarkList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('remarkNotList') and conditionParamRef.remarkNotList.size() > 0">
+            ${_conditionType_} a.remark not in
+            <foreach collection="conditionParamRef.remarkNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+
+        <if test="conditionParamRef.containsKey('createTime')">
+            <if test="conditionParamRef.createTime != null ">
+                ${_conditionType_} a.createTime = #{${_conditionParam_}.createTime}
             </if>
-            <if test="conditionParamRef.containsKey('hallIdStart') and conditionParamRef.hallIdStart != null">
-                ${_conditionType_} a.hallId <![CDATA[ >= ]]> #{${_conditionParam_}.hallIdStart}
+            <if test="conditionParamRef.createTime == null">
+                ${_conditionType_} a.createTime is null
             </if>
-            <if test="conditionParamRef.containsKey('hallIdEnd') and conditionParamRef.hallIdEnd != null">
-                ${_conditionType_} a.hallId <![CDATA[ <= ]]> #{${_conditionParam_}.hallIdEnd}
+        </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.createUserId == null">
+                ${_conditionType_} a.createUserId is null
             </if>
+        </if>
+        <if test="conditionParamRef.containsKey('createUserIdList') and conditionParamRef.createUserIdList.size() > 0">
+            ${_conditionType_} a.createUserId in
+            <foreach collection="conditionParamRef.createUserIdList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('createUserIdNotList') and conditionParamRef.createUserIdNotList.size() > 0">
+            ${_conditionType_} a.createUserId not in
+            <foreach collection="conditionParamRef.createUserIdNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('createUserIdStart') and conditionParamRef.createUserIdStart != null">
+            ${_conditionType_} a.createUserId <![CDATA[ >= ]]> #{${_conditionParam_}.createUserIdStart}
+        </if>
+        <if test="conditionParamRef.containsKey('createUserIdEnd') and conditionParamRef.createUserIdEnd != null">
+            ${_conditionType_} a.createUserId <![CDATA[ <= ]]> #{${_conditionParam_}.createUserIdEnd}
+        </if>
 
 
-            <if test="conditionParamRef.containsKey('hallName')">
-                <if test="conditionParamRef.hallName != null and conditionParamRef.hallName != ''">
-                    ${_conditionType_} a.hallName like #{${_conditionParam_}.hallName}
-                </if>
-                <if test="conditionParamRef.hallName == null">
-                    ${_conditionType_} a.hallName is null
-                </if>
+        <if test="conditionParamRef.containsKey('updateTime')">
+            <if test="conditionParamRef.updateTime != null ">
+                ${_conditionType_} a.updateTime = #{${_conditionParam_}.updateTime}
+            </if>
+            <if test="conditionParamRef.updateTime == null">
+                ${_conditionType_} a.updateTime is null
             </if>
-            <if test="conditionParamRef.containsKey('hallNameList') and conditionParamRef.hallNameList.size() > 0">
-                ${_conditionType_} a.hallName in
-                <foreach collection="conditionParamRef.hallNameList" open="(" close=")" index="index" item="item" separator=",">
+        </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
+            <if test="conditionParamRef.containsKey('idList') and conditionParamRef.idList.size() > 0">
+                field(a.id,
+                <foreach collection="conditionParamRef.idList" open="" close=")" index="index" item="item" separator=",">
                     #{item}
                 </foreach>
+                ,
             </if>
-            <if test="conditionParamRef.containsKey('hallNameNotList') and conditionParamRef.hallNameNotList.size() > 0">
-                ${_conditionType_} a.hallName not in
-                <foreach collection="conditionParamRef.hallNameNotList" open="(" close=")" index="index" item="item" separator=",">
+            <if test="conditionParamRef.containsKey('siteIdList') and conditionParamRef.siteIdList.size() > 0">
+                field(a.siteId,
+                <foreach collection="conditionParamRef.siteIdList" open="" close=")" index="index" item="item" separator=",">
                     #{item}
                 </foreach>
+                ,
             </if>
-            <if test="conditionParamRef.containsKey('sort')">
-                <if test="conditionParamRef.sort != null ">
-                    ${_conditionType_} a.sort = #{${_conditionParam_}.sort}
-                </if>
-                <if test="conditionParamRef.sort == null">
-                    ${_conditionType_} a.sort is null
-                </if>
-            </if>
-            <if test="conditionParamRef.containsKey('sortList') and conditionParamRef.sortList.size() > 0">
-                ${_conditionType_} a.sort in
-                <foreach collection="conditionParamRef.sortList" open="(" close=")" index="index" item="item" separator=",">
+            <if test="conditionParamRef.containsKey('windowIdList') and conditionParamRef.windowIdList.size() > 0">
+                field(a.windowId,
+                <foreach collection="conditionParamRef.windowIdList" open="" close=")" index="index" item="item" separator=",">
                     #{item}
                 </foreach>
+                ,
             </if>
-            <if test="conditionParamRef.containsKey('sortNotList') and conditionParamRef.sortNotList.size() > 0">
-                ${_conditionType_} a.sort not in
-                <foreach collection="conditionParamRef.sortNotList" open="(" close=")" index="index" item="item" separator=",">
+            <if test="conditionParamRef.containsKey('hallIdList') and conditionParamRef.hallIdList.size() > 0">
+                field(a.hallId,
+                <foreach collection="conditionParamRef.hallIdList" open="" close=")" index="index" item="item" separator=",">
                     #{item}
                 </foreach>
+                ,
             </if>
-            <if test="conditionParamRef.containsKey('sortStart') and conditionParamRef.sortStart != null">
-                ${_conditionType_} a.sort <![CDATA[ >= ]]> #{${_conditionParam_}.sortStart}
-            </if>
-            <if test="conditionParamRef.containsKey('sortEnd') and conditionParamRef.sortEnd != null">
-                ${_conditionType_} a.sort <![CDATA[ <= ]]> #{${_conditionParam_}.sortEnd}
-            </if>
-
-
-            <if test="conditionParamRef.containsKey('remark')">
-                <if test="conditionParamRef.remark != null and conditionParamRef.remark != ''">
-                    ${_conditionType_} a.remark like #{${_conditionParam_}.remark}
-                </if>
-                <if test="conditionParamRef.remark == null">
-                    ${_conditionType_} a.remark is null
-                </if>
-            </if>
-            <if test="conditionParamRef.containsKey('remarkList') and conditionParamRef.remarkList.size() > 0">
-                ${_conditionType_} a.remark in
-                <foreach collection="conditionParamRef.remarkList" open="(" close=")" index="index" item="item" separator=",">
+            <if test="conditionParamRef.containsKey('sortList') and conditionParamRef.sortList.size() > 0">
+                field(a.sort,
+                <foreach collection="conditionParamRef.sortList" open="" close=")" index="index" item="item" separator=",">
                     #{item}
                 </foreach>
+                ,
             </if>
-            <if test="conditionParamRef.containsKey('remarkNotList') and conditionParamRef.remarkNotList.size() > 0">
-                ${_conditionType_} a.remark not in
-                <foreach collection="conditionParamRef.remarkNotList" open="(" close=")" index="index" item="item" separator=",">
+            <if test="conditionParamRef.containsKey('createUserIdList') and conditionParamRef.createUserIdList.size() > 0">
+                field(a.createUserId,
+                <foreach collection="conditionParamRef.createUserIdList" open="" close=")" index="index" item="item" separator=",">
                     #{item}
                 </foreach>
+                ,
             </if>
-
-            <if test="conditionParamRef.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>
-            <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')
+            <trim suffixOverrides=","  suffix="">
+                <foreach collection="orderColList" open="" close="" index="index" item="item" separator=",">
+                    a.${item.colName} ${item.sortKind}
+                </foreach>
+            </trim>
+        </if>
+        <if test="(orderColList == null or orderColList.isEmpty()) and orderCol != null and !orderCol.isEmpty()">
+            order by
+            <if test="conditionParamRef.containsKey('idList') and conditionParamRef.idList.size() > 0">
+                field(a.id,
+                <foreach collection="conditionParamRef.idList" open="" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+                ,
             </if>
-            <if test="conditionParamRef.containsKey('createUserId')">
-                <if test="conditionParamRef.createUserId != null ">
-                    ${_conditionType_} a.createUserId = #{${_conditionParam_}.createUserId}
-                </if>
-                <if test="conditionParamRef.createUserId == null">
-                    ${_conditionType_} a.createUserId is null
-                </if>
+            <if test="conditionParamRef.containsKey('siteIdList') and conditionParamRef.siteIdList.size() > 0">
+                field(a.siteId,
+                <foreach collection="conditionParamRef.siteIdList" open="" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+                ,
             </if>
-            <if test="conditionParamRef.containsKey('createUserIdList') and conditionParamRef.createUserIdList.size() > 0">
-                ${_conditionType_} a.createUserId in
-                <foreach collection="conditionParamRef.createUserIdList" open="(" close=")" index="index" item="item" separator=",">
+            <if test="conditionParamRef.containsKey('windowIdList') and conditionParamRef.windowIdList.size() > 0">
+                field(a.windowId,
+                <foreach collection="conditionParamRef.windowIdList" open="" close=")" index="index" item="item" separator=",">
                     #{item}
                 </foreach>
+                ,
             </if>
-            <if test="conditionParamRef.containsKey('createUserIdNotList') and conditionParamRef.createUserIdNotList.size() > 0">
-                ${_conditionType_} a.createUserId not in
-                <foreach collection="conditionParamRef.createUserIdNotList" open="(" close=")" index="index" item="item" separator=",">
+            <if test="conditionParamRef.containsKey('hallIdList') and conditionParamRef.hallIdList.size() > 0">
+                field(a.hallId,
+                <foreach collection="conditionParamRef.hallIdList" 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 test="conditionParamRef.containsKey('sortList') and conditionParamRef.sortList.size() > 0">
+                field(a.sort,
+                <foreach collection="conditionParamRef.sortList" open="" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+                ,
             </if>
-            <if test="conditionParamRef.containsKey('createUserIdEnd') and conditionParamRef.createUserIdEnd != null">
-                ${_conditionType_} a.createUserId <![CDATA[ <= ]]> #{${_conditionParam_}.createUserIdEnd}
+            <if test="conditionParamRef.containsKey('createUserIdList') and conditionParamRef.createUserIdList.size() > 0">
+                field(a.createUserId,
+                <foreach collection="conditionParamRef.createUserIdList" open="" close=")" index="index" item="item" separator=",">
+                    #{item}
+                </foreach>
+                ,
             </if>
-
-
-            <if test="conditionParamRef.containsKey('updateTime')">
-                <if test="conditionParamRef.updateTime != null ">
-                    ${_conditionType_} a.updateTime = #{${_conditionParam_}.updateTime}
+            <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="conditionParamRef.updateTime == null">
-                    ${_conditionType_} a.updateTime is null
+                <if test="orderCol.containsKey('siteId')">
+                    a.siteId
+                    <if test='orderCol.siteId != null and "DESC".equalsIgnoreCase(orderCol.siteId)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('windowId')">
+                    a.windowId
+                    <if test='orderCol.windowId != null and "DESC".equalsIgnoreCase(orderCol.windowId)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('windowName')">
+                    a.windowName
+                    <if test='orderCol.windowName != null and "DESC".equalsIgnoreCase(orderCol.windowName)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('hallId')">
+                    a.hallId
+                    <if test='orderCol.hallId != null and "DESC".equalsIgnoreCase(orderCol.hallId)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('hallName')">
+                    a.hallName
+                    <if test='orderCol.hallName != null and "DESC".equalsIgnoreCase(orderCol.hallName)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('sort')">
+                    a.sort
+                    <if test='orderCol.sort != null and "DESC".equalsIgnoreCase(orderCol.sort)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('remark')">
+                    a.remark
+                    <if test='orderCol.remark != null and "DESC".equalsIgnoreCase(orderCol.remark)'>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>
-            <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}
-                </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('windowId')">
-                        a.windowId
-                        <if test='orderCol.windowId != null and "DESC".equalsIgnoreCase(orderCol.windowId)'>DESC</if>
-                        ,
-                    </if>
-                    <if test="orderCol.containsKey('windowName')">
-                        a.windowName
-                        <if test='orderCol.windowName != null and "DESC".equalsIgnoreCase(orderCol.windowName)'>DESC</if>
-                        ,
-                    </if>
-                    <if test="orderCol.containsKey('hallId')">
-                        a.hallId
-                        <if test='orderCol.hallId != null and "DESC".equalsIgnoreCase(orderCol.hallId)'>DESC</if>
-                        ,
-                    </if>
-                    <if test="orderCol.containsKey('hallName')">
-                        a.hallName
-                        <if test='orderCol.hallName != null and "DESC".equalsIgnoreCase(orderCol.hallName)'>DESC</if>
-                        ,
-                    </if>
-                    <if test="orderCol.containsKey('sort')">
-                        a.sort
-                        <if test='orderCol.sort != null and "DESC".equalsIgnoreCase(orderCol.sort)'>DESC</if>
-                        ,
-                    </if>
-                    <if test="orderCol.containsKey('remark')">
-                        a.remark
-                        <if test='orderCol.remark != null and "DESC".equalsIgnoreCase(orderCol.remark)'>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>
     <sql id="_group_by_">
         <if test="groupList != null and !groupList.isEmpty()">