package com.mortals.xhx.module.dept.model;

import java.util.List;

/**
 * 部门查询对象
 *
 * @author zxfei
 * @date 2024-04-24
 */
public class DeptQuery extends DeptEntity {
    /** 开始 序号，主键，自增长 */
    private Long idStart;

    /** 结束 序号，主键，自增长 */
    private Long idEnd;

    /** 增加 序号，主键，自增长 */
    private Long idIncrement;

    /** 序号，主键，自增长列表 */
    private List <Long> idList;

    /** 序号，主键，自增长排除列表 */
    private List <Long> idNotList;

    /** 从政务系统来的部门id */
    private List<String> tidList;

    /** 从政务系统来的部门id排除列表 */
    private List <String> tidNotList;
    /** 从政务系统来的部门name */
    private List<String> tnameList;

    /** 从政务系统来的部门name排除列表 */
    private List <String> tnameNotList;
    /** 部门名称 */
    private List<String> nameList;

    /** 部门名称排除列表 */
    private List <String> nameNotList;
    /** 从政务系统来的别名 */
    private List<String> simpleNameList;

    /** 从政务系统来的别名排除列表 */
    private List <String> simpleNameNotList;
    /** 开始 站点ID */
    private Long siteIdStart;

    /** 结束 站点ID */
    private Long siteIdEnd;

    /** 增加 站点ID */
    private Long siteIdIncrement;

    /** 站点ID列表 */
    private List <Long> siteIdList;

    /** 站点ID排除列表 */
    private List <Long> siteIdNotList;

    /** 部门简称 */
    private List<String> deptAbbList;

    /** 部门简称排除列表 */
    private List <String> deptAbbNotList;
    /** 部门电话 */
    private List<String> deptTelphoneList;

    /** 部门电话排除列表 */
    private List <String> deptTelphoneNotList;
    /** 部门编号 */
    private List<String> deptNumberList;

    /** 部门编号排除列表 */
    private List <String> deptNumberNotList;
    /** 开始 填单机展示 (0.否，1.是)  */
    private Integer isAutotableStart;

    /** 结束 填单机展示 (0.否，1.是)  */
    private Integer isAutotableEnd;

    /** 增加 填单机展示 (0.否，1.是)  */
    private Integer isAutotableIncrement;

    /** 填单机展示 (0.否，1.是) 列表 */
    private List <Integer> isAutotableList;

    /** 填单机展示 (0.否，1.是) 排除列表 */
    private List <Integer> isAutotableNotList;

    /** 开始 预约展示 (0.否，1.是)  */
    private Integer isOrderStart;

    /** 结束 预约展示 (0.否，1.是)  */
    private Integer isOrderEnd;

    /** 增加 预约展示 (0.否，1.是)  */
    private Integer isOrderIncrement;

    /** 预约展示 (0.否，1.是) 列表 */
    private List <Integer> isOrderList;

    /** 预约展示 (0.否，1.是) 排除列表 */
    private List <Integer> isOrderNotList;

    /** 开始 背靠背展示 (0.否，1.是)  */
    private Integer isBkbStart;

    /** 结束 背靠背展示 (0.否，1.是)  */
    private Integer isBkbEnd;

    /** 增加 背靠背展示 (0.否，1.是)  */
    private Integer isBkbIncrement;

    /** 背靠背展示 (0.否，1.是) 列表 */
    private List <Integer> isBkbList;

    /** 背靠背展示 (0.否，1.是) 排除列表 */
    private List <Integer> isBkbNotList;

    /** 开始 办事指南展示 (0.否，1.是)  */
    private Integer isWorkGuideStart;

    /** 结束 办事指南展示 (0.否，1.是)  */
    private Integer isWorkGuideEnd;

    /** 增加 办事指南展示 (0.否，1.是)  */
    private Integer isWorkGuideIncrement;

    /** 办事指南展示 (0.否，1.是) 列表 */
    private List <Integer> isWorkGuideList;

    /** 办事指南展示 (0.否，1.是) 排除列表 */
    private List <Integer> isWorkGuideNotList;

    /** 开始 是否使用 (0.否，1.是)  */
    private Integer usValidStart;

    /** 结束 是否使用 (0.否，1.是)  */
    private Integer usValidEnd;

    /** 增加 是否使用 (0.否，1.是)  */
    private Integer usValidIncrement;

    /** 是否使用 (0.否，1.是) 列表 */
    private List <Integer> usValidList;

    /** 是否使用 (0.否，1.是) 排除列表 */
    private List <Integer> usValidNotList;

    /** 开始 部门电话是否展示 (0.否，1.是)  */
    private Integer isSecphoneStart;

    /** 结束 部门电话是否展示 (0.否，1.是)  */
    private Integer isSecphoneEnd;

    /** 增加 部门电话是否展示 (0.否，1.是)  */
    private Integer isSecphoneIncrement;

    /** 部门电话是否展示 (0.否，1.是) 列表 */
    private List <Integer> isSecphoneList;

    /** 部门电话是否展示 (0.否，1.是) 排除列表 */
    private List <Integer> isSecphoneNotList;

    /** 开始 是否展示英文 (0.否，1.是)  */
    private Integer isEnglishStart;

    /** 结束 是否展示英文 (0.否，1.是)  */
    private Integer isEnglishEnd;

    /** 增加 是否展示英文 (0.否，1.是)  */
    private Integer isEnglishIncrement;

    /** 是否展示英文 (0.否，1.是) 列表 */
    private List <Integer> isEnglishList;

    /** 是否展示英文 (0.否，1.是) 排除列表 */
    private List <Integer> isEnglishNotList;

    /** 开始 排序 */
    private Integer sortStart;

    /** 结束 排序 */
    private Integer sortEnd;

    /** 增加 排序 */
    private Integer sortIncrement;

    /** 排序列表 */
    private List <Integer> sortList;

    /** 排序排除列表 */
    private List <Integer> sortNotList;

    /** 开始 部门来源 */
    private Integer sourceStart;

    /** 结束 部门来源 */
    private Integer sourceEnd;

    /** 增加 部门来源 */
    private Integer sourceIncrement;

    /** 部门来源列表 */
    private List <Integer> sourceList;

    /** 部门来源排除列表 */
    private List <Integer> sourceNotList;

    /** 开始 关联事项数量 */
    private Integer totalStart;

    /** 结束 关联事项数量 */
    private Integer totalEnd;

    /** 增加 关联事项数量 */
    private Integer totalIncrement;

    /** 关联事项数量列表 */
    private List <Integer> totalList;

    /** 关联事项数量排除列表 */
    private List <Integer> totalNotList;

    /** 开始 入驻事项数量 */
    private Integer inNumStart;

    /** 结束 入驻事项数量 */
    private Integer inNumEnd;

    /** 增加 入驻事项数量 */
    private Integer inNumIncrement;

    /** 入驻事项数量列表 */
    private List <Integer> inNumList;

    /** 入驻事项数量排除列表 */
    private List <Integer> inNumNotList;

    /** 开始 创建时间 */
    private String createTimeStart;

    /** 结束 创建时间 */
    private String createTimeEnd;

    /** 开始 创建用户 */
    private Long createUserIdStart;

    /** 结束 创建用户 */
    private Long createUserIdEnd;

    /** 增加 创建用户 */
    private Long createUserIdIncrement;

    /** 创建用户列表 */
    private List <Long> createUserIdList;

    /** 创建用户排除列表 */
    private List <Long> createUserIdNotList;

    /** 开始 修改时间 */
    private String updateTimeStart;

    /** 结束 修改时间 */
    private String updateTimeEnd;

    /** OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4) */
    private List<DeptQuery> orConditionList;

    /** AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4) */
    private List<DeptQuery> andConditionList;

    public DeptQuery(){}

    /**
     * 获取 开始 序号，主键，自增长
     * @return idStart
     */
    public Long getIdStart(){
        return this.idStart;
    }

    /**
     * 设置 开始 序号，主键，自增长
     * @param idStart
     */
    public void setIdStart(Long idStart){
        this.idStart = idStart;
    }

    /**
     * 获取 结束 序号，主键，自增长
     * @return $idEnd
     */
    public Long getIdEnd(){
        return this.idEnd;
    }

    /**
     * 设置 结束 序号，主键，自增长
     * @param idEnd
     */
    public void setIdEnd(Long idEnd){
        this.idEnd = idEnd;
    }

    /**
     * 获取 增加 序号，主键，自增长
     * @return idIncrement
     */
    public Long getIdIncrement(){
        return this.idIncrement;
    }

    /**
     * 设置 增加 序号，主键，自增长
     * @param idIncrement
     */
    public void setIdIncrement(Long idIncrement){
        this.idIncrement = idIncrement;
    }

    /**
     * 获取 序号，主键，自增长
     * @return idList
     */
    public List<Long> getIdList(){
        return this.idList;
    }

    /**
     * 设置 序号，主键，自增长
     * @param idList
     */
    public void setIdList(List<Long> idList){
        this.idList = idList;
    }

    /**
     * 获取 序号，主键，自增长
     * @return idNotList
     */
    public List<Long> getIdNotList(){
        return this.idNotList;
    }

    /**
     * 设置 序号，主键，自增长
     * @param idNotList
     */
    public void setIdNotList(List<Long> idNotList){
        this.idNotList = idNotList;
    }


    /**
     * 获取 从政务系统来的部门id
     * @return tidList
     */
    public List<String> getTidList(){
        return this.tidList;
    }

    /**
     * 设置 从政务系统来的部门id
     * @param tidList
     */
    public void setTidList(List<String> tidList){
        this.tidList = tidList;
    }

    /**
     * 获取 从政务系统来的部门id
     * @return tidNotList
     */
    public List<String> getTidNotList(){
        return this.tidNotList;
    }

    /**
     * 设置 从政务系统来的部门id
     * @param tidNotList
     */
    public void setTidNotList(List<String> tidNotList){
        this.tidNotList = tidNotList;
    }

    /**
     * 获取 从政务系统来的部门name
     * @return tnameList
     */
    public List<String> getTnameList(){
        return this.tnameList;
    }

    /**
     * 设置 从政务系统来的部门name
     * @param tnameList
     */
    public void setTnameList(List<String> tnameList){
        this.tnameList = tnameList;
    }

    /**
     * 获取 从政务系统来的部门name
     * @return tnameNotList
     */
    public List<String> getTnameNotList(){
        return this.tnameNotList;
    }

    /**
     * 设置 从政务系统来的部门name
     * @param tnameNotList
     */
    public void setTnameNotList(List<String> tnameNotList){
        this.tnameNotList = tnameNotList;
    }

    /**
     * 获取 部门名称
     * @return nameList
     */
    public List<String> getNameList(){
        return this.nameList;
    }

    /**
     * 设置 部门名称
     * @param nameList
     */
    public void setNameList(List<String> nameList){
        this.nameList = nameList;
    }

    /**
     * 获取 部门名称
     * @return nameNotList
     */
    public List<String> getNameNotList(){
        return this.nameNotList;
    }

    /**
     * 设置 部门名称
     * @param nameNotList
     */
    public void setNameNotList(List<String> nameNotList){
        this.nameNotList = nameNotList;
    }

    /**
     * 获取 从政务系统来的别名
     * @return simpleNameList
     */
    public List<String> getSimpleNameList(){
        return this.simpleNameList;
    }

    /**
     * 设置 从政务系统来的别名
     * @param simpleNameList
     */
    public void setSimpleNameList(List<String> simpleNameList){
        this.simpleNameList = simpleNameList;
    }

    /**
     * 获取 从政务系统来的别名
     * @return simpleNameNotList
     */
    public List<String> getSimpleNameNotList(){
        return this.simpleNameNotList;
    }

    /**
     * 设置 从政务系统来的别名
     * @param simpleNameNotList
     */
    public void setSimpleNameNotList(List<String> simpleNameNotList){
        this.simpleNameNotList = simpleNameNotList;
    }

    /**
     * 获取 开始 站点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;
    }


    /**
     * 获取 部门简称
     * @return deptAbbList
     */
    public List<String> getDeptAbbList(){
        return this.deptAbbList;
    }

    /**
     * 设置 部门简称
     * @param deptAbbList
     */
    public void setDeptAbbList(List<String> deptAbbList){
        this.deptAbbList = deptAbbList;
    }

    /**
     * 获取 部门简称
     * @return deptAbbNotList
     */
    public List<String> getDeptAbbNotList(){
        return this.deptAbbNotList;
    }

    /**
     * 设置 部门简称
     * @param deptAbbNotList
     */
    public void setDeptAbbNotList(List<String> deptAbbNotList){
        this.deptAbbNotList = deptAbbNotList;
    }

    /**
     * 获取 部门电话
     * @return deptTelphoneList
     */
    public List<String> getDeptTelphoneList(){
        return this.deptTelphoneList;
    }

    /**
     * 设置 部门电话
     * @param deptTelphoneList
     */
    public void setDeptTelphoneList(List<String> deptTelphoneList){
        this.deptTelphoneList = deptTelphoneList;
    }

    /**
     * 获取 部门电话
     * @return deptTelphoneNotList
     */
    public List<String> getDeptTelphoneNotList(){
        return this.deptTelphoneNotList;
    }

    /**
     * 设置 部门电话
     * @param deptTelphoneNotList
     */
    public void setDeptTelphoneNotList(List<String> deptTelphoneNotList){
        this.deptTelphoneNotList = deptTelphoneNotList;
    }

    /**
     * 获取 部门编号
     * @return deptNumberList
     */
    public List<String> getDeptNumberList(){
        return this.deptNumberList;
    }

    /**
     * 设置 部门编号
     * @param deptNumberList
     */
    public void setDeptNumberList(List<String> deptNumberList){
        this.deptNumberList = deptNumberList;
    }

    /**
     * 获取 部门编号
     * @return deptNumberNotList
     */
    public List<String> getDeptNumberNotList(){
        return this.deptNumberNotList;
    }

    /**
     * 设置 部门编号
     * @param deptNumberNotList
     */
    public void setDeptNumberNotList(List<String> deptNumberNotList){
        this.deptNumberNotList = deptNumberNotList;
    }

    /**
     * 获取 开始 填单机展示 (0.否，1.是)
     * @return isAutotableStart
     */
    public Integer getIsAutotableStart(){
        return this.isAutotableStart;
    }

    /**
     * 设置 开始 填单机展示 (0.否，1.是)
     * @param isAutotableStart
     */
    public void setIsAutotableStart(Integer isAutotableStart){
        this.isAutotableStart = isAutotableStart;
    }

    /**
     * 获取 结束 填单机展示 (0.否，1.是)
     * @return $isAutotableEnd
     */
    public Integer getIsAutotableEnd(){
        return this.isAutotableEnd;
    }

    /**
     * 设置 结束 填单机展示 (0.否，1.是)
     * @param isAutotableEnd
     */
    public void setIsAutotableEnd(Integer isAutotableEnd){
        this.isAutotableEnd = isAutotableEnd;
    }

    /**
     * 获取 增加 填单机展示 (0.否，1.是)
     * @return isAutotableIncrement
     */
    public Integer getIsAutotableIncrement(){
        return this.isAutotableIncrement;
    }

    /**
     * 设置 增加 填单机展示 (0.否，1.是)
     * @param isAutotableIncrement
     */
    public void setIsAutotableIncrement(Integer isAutotableIncrement){
        this.isAutotableIncrement = isAutotableIncrement;
    }

    /**
     * 获取 填单机展示 (0.否，1.是)
     * @return isAutotableList
     */
    public List<Integer> getIsAutotableList(){
        return this.isAutotableList;
    }

    /**
     * 设置 填单机展示 (0.否，1.是)
     * @param isAutotableList
     */
    public void setIsAutotableList(List<Integer> isAutotableList){
        this.isAutotableList = isAutotableList;
    }

    /**
     * 获取 填单机展示 (0.否，1.是)
     * @return isAutotableNotList
     */
    public List<Integer> getIsAutotableNotList(){
        return this.isAutotableNotList;
    }

    /**
     * 设置 填单机展示 (0.否，1.是)
     * @param isAutotableNotList
     */
    public void setIsAutotableNotList(List<Integer> isAutotableNotList){
        this.isAutotableNotList = isAutotableNotList;
    }


    /**
     * 获取 开始 预约展示 (0.否，1.是)
     * @return isOrderStart
     */
    public Integer getIsOrderStart(){
        return this.isOrderStart;
    }

    /**
     * 设置 开始 预约展示 (0.否，1.是)
     * @param isOrderStart
     */
    public void setIsOrderStart(Integer isOrderStart){
        this.isOrderStart = isOrderStart;
    }

    /**
     * 获取 结束 预约展示 (0.否，1.是)
     * @return $isOrderEnd
     */
    public Integer getIsOrderEnd(){
        return this.isOrderEnd;
    }

    /**
     * 设置 结束 预约展示 (0.否，1.是)
     * @param isOrderEnd
     */
    public void setIsOrderEnd(Integer isOrderEnd){
        this.isOrderEnd = isOrderEnd;
    }

    /**
     * 获取 增加 预约展示 (0.否，1.是)
     * @return isOrderIncrement
     */
    public Integer getIsOrderIncrement(){
        return this.isOrderIncrement;
    }

    /**
     * 设置 增加 预约展示 (0.否，1.是)
     * @param isOrderIncrement
     */
    public void setIsOrderIncrement(Integer isOrderIncrement){
        this.isOrderIncrement = isOrderIncrement;
    }

    /**
     * 获取 预约展示 (0.否，1.是)
     * @return isOrderList
     */
    public List<Integer> getIsOrderList(){
        return this.isOrderList;
    }

    /**
     * 设置 预约展示 (0.否，1.是)
     * @param isOrderList
     */
    public void setIsOrderList(List<Integer> isOrderList){
        this.isOrderList = isOrderList;
    }

    /**
     * 获取 预约展示 (0.否，1.是)
     * @return isOrderNotList
     */
    public List<Integer> getIsOrderNotList(){
        return this.isOrderNotList;
    }

    /**
     * 设置 预约展示 (0.否，1.是)
     * @param isOrderNotList
     */
    public void setIsOrderNotList(List<Integer> isOrderNotList){
        this.isOrderNotList = isOrderNotList;
    }


    /**
     * 获取 开始 背靠背展示 (0.否，1.是)
     * @return isBkbStart
     */
    public Integer getIsBkbStart(){
        return this.isBkbStart;
    }

    /**
     * 设置 开始 背靠背展示 (0.否，1.是)
     * @param isBkbStart
     */
    public void setIsBkbStart(Integer isBkbStart){
        this.isBkbStart = isBkbStart;
    }

    /**
     * 获取 结束 背靠背展示 (0.否，1.是)
     * @return $isBkbEnd
     */
    public Integer getIsBkbEnd(){
        return this.isBkbEnd;
    }

    /**
     * 设置 结束 背靠背展示 (0.否，1.是)
     * @param isBkbEnd
     */
    public void setIsBkbEnd(Integer isBkbEnd){
        this.isBkbEnd = isBkbEnd;
    }

    /**
     * 获取 增加 背靠背展示 (0.否，1.是)
     * @return isBkbIncrement
     */
    public Integer getIsBkbIncrement(){
        return this.isBkbIncrement;
    }

    /**
     * 设置 增加 背靠背展示 (0.否，1.是)
     * @param isBkbIncrement
     */
    public void setIsBkbIncrement(Integer isBkbIncrement){
        this.isBkbIncrement = isBkbIncrement;
    }

    /**
     * 获取 背靠背展示 (0.否，1.是)
     * @return isBkbList
     */
    public List<Integer> getIsBkbList(){
        return this.isBkbList;
    }

    /**
     * 设置 背靠背展示 (0.否，1.是)
     * @param isBkbList
     */
    public void setIsBkbList(List<Integer> isBkbList){
        this.isBkbList = isBkbList;
    }

    /**
     * 获取 背靠背展示 (0.否，1.是)
     * @return isBkbNotList
     */
    public List<Integer> getIsBkbNotList(){
        return this.isBkbNotList;
    }

    /**
     * 设置 背靠背展示 (0.否，1.是)
     * @param isBkbNotList
     */
    public void setIsBkbNotList(List<Integer> isBkbNotList){
        this.isBkbNotList = isBkbNotList;
    }


    /**
     * 获取 开始 办事指南展示 (0.否，1.是)
     * @return isWorkGuideStart
     */
    public Integer getIsWorkGuideStart(){
        return this.isWorkGuideStart;
    }

    /**
     * 设置 开始 办事指南展示 (0.否，1.是)
     * @param isWorkGuideStart
     */
    public void setIsWorkGuideStart(Integer isWorkGuideStart){
        this.isWorkGuideStart = isWorkGuideStart;
    }

    /**
     * 获取 结束 办事指南展示 (0.否，1.是)
     * @return $isWorkGuideEnd
     */
    public Integer getIsWorkGuideEnd(){
        return this.isWorkGuideEnd;
    }

    /**
     * 设置 结束 办事指南展示 (0.否，1.是)
     * @param isWorkGuideEnd
     */
    public void setIsWorkGuideEnd(Integer isWorkGuideEnd){
        this.isWorkGuideEnd = isWorkGuideEnd;
    }

    /**
     * 获取 增加 办事指南展示 (0.否，1.是)
     * @return isWorkGuideIncrement
     */
    public Integer getIsWorkGuideIncrement(){
        return this.isWorkGuideIncrement;
    }

    /**
     * 设置 增加 办事指南展示 (0.否，1.是)
     * @param isWorkGuideIncrement
     */
    public void setIsWorkGuideIncrement(Integer isWorkGuideIncrement){
        this.isWorkGuideIncrement = isWorkGuideIncrement;
    }

    /**
     * 获取 办事指南展示 (0.否，1.是)
     * @return isWorkGuideList
     */
    public List<Integer> getIsWorkGuideList(){
        return this.isWorkGuideList;
    }

    /**
     * 设置 办事指南展示 (0.否，1.是)
     * @param isWorkGuideList
     */
    public void setIsWorkGuideList(List<Integer> isWorkGuideList){
        this.isWorkGuideList = isWorkGuideList;
    }

    /**
     * 获取 办事指南展示 (0.否，1.是)
     * @return isWorkGuideNotList
     */
    public List<Integer> getIsWorkGuideNotList(){
        return this.isWorkGuideNotList;
    }

    /**
     * 设置 办事指南展示 (0.否，1.是)
     * @param isWorkGuideNotList
     */
    public void setIsWorkGuideNotList(List<Integer> isWorkGuideNotList){
        this.isWorkGuideNotList = isWorkGuideNotList;
    }


    /**
     * 获取 开始 是否使用 (0.否，1.是)
     * @return usValidStart
     */
    public Integer getUsValidStart(){
        return this.usValidStart;
    }

    /**
     * 设置 开始 是否使用 (0.否，1.是)
     * @param usValidStart
     */
    public void setUsValidStart(Integer usValidStart){
        this.usValidStart = usValidStart;
    }

    /**
     * 获取 结束 是否使用 (0.否，1.是)
     * @return $usValidEnd
     */
    public Integer getUsValidEnd(){
        return this.usValidEnd;
    }

    /**
     * 设置 结束 是否使用 (0.否，1.是)
     * @param usValidEnd
     */
    public void setUsValidEnd(Integer usValidEnd){
        this.usValidEnd = usValidEnd;
    }

    /**
     * 获取 增加 是否使用 (0.否，1.是)
     * @return usValidIncrement
     */
    public Integer getUsValidIncrement(){
        return this.usValidIncrement;
    }

    /**
     * 设置 增加 是否使用 (0.否，1.是)
     * @param usValidIncrement
     */
    public void setUsValidIncrement(Integer usValidIncrement){
        this.usValidIncrement = usValidIncrement;
    }

    /**
     * 获取 是否使用 (0.否，1.是)
     * @return usValidList
     */
    public List<Integer> getUsValidList(){
        return this.usValidList;
    }

    /**
     * 设置 是否使用 (0.否，1.是)
     * @param usValidList
     */
    public void setUsValidList(List<Integer> usValidList){
        this.usValidList = usValidList;
    }

    /**
     * 获取 是否使用 (0.否，1.是)
     * @return usValidNotList
     */
    public List<Integer> getUsValidNotList(){
        return this.usValidNotList;
    }

    /**
     * 设置 是否使用 (0.否，1.是)
     * @param usValidNotList
     */
    public void setUsValidNotList(List<Integer> usValidNotList){
        this.usValidNotList = usValidNotList;
    }


    /**
     * 获取 开始 部门电话是否展示 (0.否，1.是)
     * @return isSecphoneStart
     */
    public Integer getIsSecphoneStart(){
        return this.isSecphoneStart;
    }

    /**
     * 设置 开始 部门电话是否展示 (0.否，1.是)
     * @param isSecphoneStart
     */
    public void setIsSecphoneStart(Integer isSecphoneStart){
        this.isSecphoneStart = isSecphoneStart;
    }

    /**
     * 获取 结束 部门电话是否展示 (0.否，1.是)
     * @return $isSecphoneEnd
     */
    public Integer getIsSecphoneEnd(){
        return this.isSecphoneEnd;
    }

    /**
     * 设置 结束 部门电话是否展示 (0.否，1.是)
     * @param isSecphoneEnd
     */
    public void setIsSecphoneEnd(Integer isSecphoneEnd){
        this.isSecphoneEnd = isSecphoneEnd;
    }

    /**
     * 获取 增加 部门电话是否展示 (0.否，1.是)
     * @return isSecphoneIncrement
     */
    public Integer getIsSecphoneIncrement(){
        return this.isSecphoneIncrement;
    }

    /**
     * 设置 增加 部门电话是否展示 (0.否，1.是)
     * @param isSecphoneIncrement
     */
    public void setIsSecphoneIncrement(Integer isSecphoneIncrement){
        this.isSecphoneIncrement = isSecphoneIncrement;
    }

    /**
     * 获取 部门电话是否展示 (0.否，1.是)
     * @return isSecphoneList
     */
    public List<Integer> getIsSecphoneList(){
        return this.isSecphoneList;
    }

    /**
     * 设置 部门电话是否展示 (0.否，1.是)
     * @param isSecphoneList
     */
    public void setIsSecphoneList(List<Integer> isSecphoneList){
        this.isSecphoneList = isSecphoneList;
    }

    /**
     * 获取 部门电话是否展示 (0.否，1.是)
     * @return isSecphoneNotList
     */
    public List<Integer> getIsSecphoneNotList(){
        return this.isSecphoneNotList;
    }

    /**
     * 设置 部门电话是否展示 (0.否，1.是)
     * @param isSecphoneNotList
     */
    public void setIsSecphoneNotList(List<Integer> isSecphoneNotList){
        this.isSecphoneNotList = isSecphoneNotList;
    }


    /**
     * 获取 开始 是否展示英文 (0.否，1.是)
     * @return isEnglishStart
     */
    public Integer getIsEnglishStart(){
        return this.isEnglishStart;
    }

    /**
     * 设置 开始 是否展示英文 (0.否，1.是)
     * @param isEnglishStart
     */
    public void setIsEnglishStart(Integer isEnglishStart){
        this.isEnglishStart = isEnglishStart;
    }

    /**
     * 获取 结束 是否展示英文 (0.否，1.是)
     * @return $isEnglishEnd
     */
    public Integer getIsEnglishEnd(){
        return this.isEnglishEnd;
    }

    /**
     * 设置 结束 是否展示英文 (0.否，1.是)
     * @param isEnglishEnd
     */
    public void setIsEnglishEnd(Integer isEnglishEnd){
        this.isEnglishEnd = isEnglishEnd;
    }

    /**
     * 获取 增加 是否展示英文 (0.否，1.是)
     * @return isEnglishIncrement
     */
    public Integer getIsEnglishIncrement(){
        return this.isEnglishIncrement;
    }

    /**
     * 设置 增加 是否展示英文 (0.否，1.是)
     * @param isEnglishIncrement
     */
    public void setIsEnglishIncrement(Integer isEnglishIncrement){
        this.isEnglishIncrement = isEnglishIncrement;
    }

    /**
     * 获取 是否展示英文 (0.否，1.是)
     * @return isEnglishList
     */
    public List<Integer> getIsEnglishList(){
        return this.isEnglishList;
    }

    /**
     * 设置 是否展示英文 (0.否，1.是)
     * @param isEnglishList
     */
    public void setIsEnglishList(List<Integer> isEnglishList){
        this.isEnglishList = isEnglishList;
    }

    /**
     * 获取 是否展示英文 (0.否，1.是)
     * @return isEnglishNotList
     */
    public List<Integer> getIsEnglishNotList(){
        return this.isEnglishNotList;
    }

    /**
     * 设置 是否展示英文 (0.否，1.是)
     * @param isEnglishNotList
     */
    public void setIsEnglishNotList(List<Integer> isEnglishNotList){
        this.isEnglishNotList = isEnglishNotList;
    }


    /**
     * 获取 开始 排序
     * @return sortStart
     */
    public Integer getSortStart(){
        return this.sortStart;
    }

    /**
     * 设置 开始 排序
     * @param sortStart
     */
    public void setSortStart(Integer sortStart){
        this.sortStart = sortStart;
    }

    /**
     * 获取 结束 排序
     * @return $sortEnd
     */
    public Integer getSortEnd(){
        return this.sortEnd;
    }

    /**
     * 设置 结束 排序
     * @param sortEnd
     */
    public void setSortEnd(Integer sortEnd){
        this.sortEnd = sortEnd;
    }

    /**
     * 获取 增加 排序
     * @return sortIncrement
     */
    public Integer getSortIncrement(){
        return this.sortIncrement;
    }

    /**
     * 设置 增加 排序
     * @param sortIncrement
     */
    public void setSortIncrement(Integer sortIncrement){
        this.sortIncrement = sortIncrement;
    }

    /**
     * 获取 排序
     * @return sortList
     */
    public List<Integer> getSortList(){
        return this.sortList;
    }

    /**
     * 设置 排序
     * @param sortList
     */
    public void setSortList(List<Integer> sortList){
        this.sortList = sortList;
    }

    /**
     * 获取 排序
     * @return sortNotList
     */
    public List<Integer> getSortNotList(){
        return this.sortNotList;
    }

    /**
     * 设置 排序
     * @param sortNotList
     */
    public void setSortNotList(List<Integer> sortNotList){
        this.sortNotList = sortNotList;
    }


    /**
     * 获取 开始 部门来源
     * @return sourceStart
     */
    public Integer getSourceStart(){
        return this.sourceStart;
    }

    /**
     * 设置 开始 部门来源
     * @param sourceStart
     */
    public void setSourceStart(Integer sourceStart){
        this.sourceStart = sourceStart;
    }

    /**
     * 获取 结束 部门来源
     * @return $sourceEnd
     */
    public Integer getSourceEnd(){
        return this.sourceEnd;
    }

    /**
     * 设置 结束 部门来源
     * @param sourceEnd
     */
    public void setSourceEnd(Integer sourceEnd){
        this.sourceEnd = sourceEnd;
    }

    /**
     * 获取 增加 部门来源
     * @return sourceIncrement
     */
    public Integer getSourceIncrement(){
        return this.sourceIncrement;
    }

    /**
     * 设置 增加 部门来源
     * @param sourceIncrement
     */
    public void setSourceIncrement(Integer sourceIncrement){
        this.sourceIncrement = sourceIncrement;
    }

    /**
     * 获取 部门来源
     * @return sourceList
     */
    public List<Integer> getSourceList(){
        return this.sourceList;
    }

    /**
     * 设置 部门来源
     * @param sourceList
     */
    public void setSourceList(List<Integer> sourceList){
        this.sourceList = sourceList;
    }

    /**
     * 获取 部门来源
     * @return sourceNotList
     */
    public List<Integer> getSourceNotList(){
        return this.sourceNotList;
    }

    /**
     * 设置 部门来源
     * @param sourceNotList
     */
    public void setSourceNotList(List<Integer> sourceNotList){
        this.sourceNotList = sourceNotList;
    }


    /**
     * 获取 开始 关联事项数量
     * @return totalStart
     */
    public Integer getTotalStart(){
        return this.totalStart;
    }

    /**
     * 设置 开始 关联事项数量
     * @param totalStart
     */
    public void setTotalStart(Integer totalStart){
        this.totalStart = totalStart;
    }

    /**
     * 获取 结束 关联事项数量
     * @return $totalEnd
     */
    public Integer getTotalEnd(){
        return this.totalEnd;
    }

    /**
     * 设置 结束 关联事项数量
     * @param totalEnd
     */
    public void setTotalEnd(Integer totalEnd){
        this.totalEnd = totalEnd;
    }

    /**
     * 获取 增加 关联事项数量
     * @return totalIncrement
     */
    public Integer getTotalIncrement(){
        return this.totalIncrement;
    }

    /**
     * 设置 增加 关联事项数量
     * @param totalIncrement
     */
    public void setTotalIncrement(Integer totalIncrement){
        this.totalIncrement = totalIncrement;
    }

    /**
     * 获取 关联事项数量
     * @return totalList
     */
    public List<Integer> getTotalList(){
        return this.totalList;
    }

    /**
     * 设置 关联事项数量
     * @param totalList
     */
    public void setTotalList(List<Integer> totalList){
        this.totalList = totalList;
    }

    /**
     * 获取 关联事项数量
     * @return totalNotList
     */
    public List<Integer> getTotalNotList(){
        return this.totalNotList;
    }

    /**
     * 设置 关联事项数量
     * @param totalNotList
     */
    public void setTotalNotList(List<Integer> totalNotList){
        this.totalNotList = totalNotList;
    }


    /**
     * 获取 开始 入驻事项数量
     * @return inNumStart
     */
    public Integer getInNumStart(){
        return this.inNumStart;
    }

    /**
     * 设置 开始 入驻事项数量
     * @param inNumStart
     */
    public void setInNumStart(Integer inNumStart){
        this.inNumStart = inNumStart;
    }

    /**
     * 获取 结束 入驻事项数量
     * @return $inNumEnd
     */
    public Integer getInNumEnd(){
        return this.inNumEnd;
    }

    /**
     * 设置 结束 入驻事项数量
     * @param inNumEnd
     */
    public void setInNumEnd(Integer inNumEnd){
        this.inNumEnd = inNumEnd;
    }

    /**
     * 获取 增加 入驻事项数量
     * @return inNumIncrement
     */
    public Integer getInNumIncrement(){
        return this.inNumIncrement;
    }

    /**
     * 设置 增加 入驻事项数量
     * @param inNumIncrement
     */
    public void setInNumIncrement(Integer inNumIncrement){
        this.inNumIncrement = inNumIncrement;
    }

    /**
     * 获取 入驻事项数量
     * @return inNumList
     */
    public List<Integer> getInNumList(){
        return this.inNumList;
    }

    /**
     * 设置 入驻事项数量
     * @param inNumList
     */
    public void setInNumList(List<Integer> inNumList){
        this.inNumList = inNumList;
    }

    /**
     * 获取 入驻事项数量
     * @return inNumNotList
     */
    public List<Integer> getInNumNotList(){
        return this.inNumNotList;
    }

    /**
     * 设置 入驻事项数量
     * @param inNumNotList
     */
    public void setInNumNotList(List<Integer> inNumNotList){
        this.inNumNotList = inNumNotList;
    }


    /**
     * 获取 开始 创建时间
     * @return createTimeStart
     */
    public String getCreateTimeStart(){
        return this.createTimeStart;
    }

    /**
     * 设置 开始 创建时间
     * @param createTimeStart
     */
    public void setCreateTimeStart(String createTimeStart){
        this.createTimeStart = createTimeStart;
    }

    /**
     * 获取 结束 创建时间
     * @return createTimeEnd
     */
    public String getCreateTimeEnd(){
        return this.createTimeEnd;
    }

    /**
     * 设置 结束 创建时间
     * @param createTimeEnd
     */
    public void setCreateTimeEnd(String createTimeEnd){
        this.createTimeEnd = createTimeEnd;
    }

    /**
     * 获取 开始 创建用户
     * @return createUserIdStart
     */
    public Long getCreateUserIdStart(){
        return this.createUserIdStart;
    }

    /**
     * 设置 开始 创建用户
     * @param createUserIdStart
     */
    public void setCreateUserIdStart(Long createUserIdStart){
        this.createUserIdStart = createUserIdStart;
    }

    /**
     * 获取 结束 创建用户
     * @return $createUserIdEnd
     */
    public Long getCreateUserIdEnd(){
        return this.createUserIdEnd;
    }

    /**
     * 设置 结束 创建用户
     * @param createUserIdEnd
     */
    public void setCreateUserIdEnd(Long createUserIdEnd){
        this.createUserIdEnd = createUserIdEnd;
    }

    /**
     * 获取 增加 创建用户
     * @return createUserIdIncrement
     */
    public Long getCreateUserIdIncrement(){
        return this.createUserIdIncrement;
    }

    /**
     * 设置 增加 创建用户
     * @param createUserIdIncrement
     */
    public void setCreateUserIdIncrement(Long createUserIdIncrement){
        this.createUserIdIncrement = createUserIdIncrement;
    }

    /**
     * 获取 创建用户
     * @return createUserIdList
     */
    public List<Long> getCreateUserIdList(){
        return this.createUserIdList;
    }

    /**
     * 设置 创建用户
     * @param createUserIdList
     */
    public void setCreateUserIdList(List<Long> createUserIdList){
        this.createUserIdList = createUserIdList;
    }

    /**
     * 获取 创建用户
     * @return createUserIdNotList
     */
    public List<Long> getCreateUserIdNotList(){
        return this.createUserIdNotList;
    }

    /**
     * 设置 创建用户
     * @param createUserIdNotList
     */
    public void setCreateUserIdNotList(List<Long> createUserIdNotList){
        this.createUserIdNotList = createUserIdNotList;
    }


    /**
     * 获取 开始 修改时间
     * @return updateTimeStart
     */
    public String getUpdateTimeStart(){
        return this.updateTimeStart;
    }

    /**
     * 设置 开始 修改时间
     * @param updateTimeStart
     */
    public void setUpdateTimeStart(String updateTimeStart){
        this.updateTimeStart = updateTimeStart;
    }

    /**
     * 获取 结束 修改时间
     * @return updateTimeEnd
     */
    public String getUpdateTimeEnd(){
        return this.updateTimeEnd;
    }

    /**
     * 设置 结束 修改时间
     * @param updateTimeEnd
     */
    public void setUpdateTimeEnd(String updateTimeEnd){
        this.updateTimeEnd = updateTimeEnd;
    }

    /**
     * 设置  序号，主键，自增长
     * @param id
     */
    public DeptQuery id(Long id){
        setId(id);
        return this;
    }

    /**
     * 设置 开始 序号，主键，自增长
     * @param idStart
     */
    public DeptQuery idStart(Long idStart){
        this.idStart = idStart;
        return this;
    }

    /**
     * 设置 结束 序号，主键，自增长
     * @param idEnd
     */
    public DeptQuery idEnd(Long idEnd){
        this.idEnd = idEnd;
        return this;
    }

    /**
     * 设置 增加 序号，主键，自增长
     * @param idIncrement
     */
    public DeptQuery idIncrement(Long idIncrement){
        this.idIncrement = idIncrement;
        return this;
    }

    /**
     * 设置 序号，主键，自增长
     * @param idList
     */
    public DeptQuery idList(List<Long> idList){
        this.idList = idList;
        return this;
    }

    /**
     * 设置 序号，主键，自增长
     * @param idNotList
     */
    public DeptQuery idNotList(List<Long> idNotList){
        this.idNotList = idNotList;
        return this;
    }


    /**
     * 设置 从政务系统来的部门id
     * @param tid
     */
    public DeptQuery tid(String tid){
        setTid(tid);
        return this;
    }

    /**
     * 设置 从政务系统来的部门id
     * @param tidList
     */
    public DeptQuery tidList(List<String> tidList){
        this.tidList = tidList;
        return this;
    }


    /**
     * 设置 从政务系统来的部门name
     * @param tname
     */
    public DeptQuery tname(String tname){
        setTname(tname);
        return this;
    }

    /**
     * 设置 从政务系统来的部门name
     * @param tnameList
     */
    public DeptQuery tnameList(List<String> tnameList){
        this.tnameList = tnameList;
        return this;
    }


    /**
     * 设置 部门名称
     * @param name
     */
    public DeptQuery name(String name){
        setName(name);
        return this;
    }

    /**
     * 设置 部门名称
     * @param nameList
     */
    public DeptQuery nameList(List<String> nameList){
        this.nameList = nameList;
        return this;
    }


    /**
     * 设置 从政务系统来的别名
     * @param simpleName
     */
    public DeptQuery simpleName(String simpleName){
        setSimpleName(simpleName);
        return this;
    }

    /**
     * 设置 从政务系统来的别名
     * @param simpleNameList
     */
    public DeptQuery simpleNameList(List<String> simpleNameList){
        this.simpleNameList = simpleNameList;
        return this;
    }

    /**
     * 设置  站点ID
     * @param siteId
     */
    public DeptQuery siteId(Long siteId){
        setSiteId(siteId);
        return this;
    }

    /**
     * 设置 开始 站点ID
     * @param siteIdStart
     */
    public DeptQuery siteIdStart(Long siteIdStart){
        this.siteIdStart = siteIdStart;
        return this;
    }

    /**
     * 设置 结束 站点ID
     * @param siteIdEnd
     */
    public DeptQuery siteIdEnd(Long siteIdEnd){
        this.siteIdEnd = siteIdEnd;
        return this;
    }

    /**
     * 设置 增加 站点ID
     * @param siteIdIncrement
     */
    public DeptQuery siteIdIncrement(Long siteIdIncrement){
        this.siteIdIncrement = siteIdIncrement;
        return this;
    }

    /**
     * 设置 站点ID
     * @param siteIdList
     */
    public DeptQuery siteIdList(List<Long> siteIdList){
        this.siteIdList = siteIdList;
        return this;
    }

    /**
     * 设置 站点ID
     * @param siteIdNotList
     */
    public DeptQuery siteIdNotList(List<Long> siteIdNotList){
        this.siteIdNotList = siteIdNotList;
        return this;
    }


    /**
     * 设置 部门简称
     * @param deptAbb
     */
    public DeptQuery deptAbb(String deptAbb){
        setDeptAbb(deptAbb);
        return this;
    }

    /**
     * 设置 部门简称
     * @param deptAbbList
     */
    public DeptQuery deptAbbList(List<String> deptAbbList){
        this.deptAbbList = deptAbbList;
        return this;
    }


    /**
     * 设置 部门电话
     * @param deptTelphone
     */
    public DeptQuery deptTelphone(String deptTelphone){
        setDeptTelphone(deptTelphone);
        return this;
    }

    /**
     * 设置 部门电话
     * @param deptTelphoneList
     */
    public DeptQuery deptTelphoneList(List<String> deptTelphoneList){
        this.deptTelphoneList = deptTelphoneList;
        return this;
    }


    /**
     * 设置 部门编号
     * @param deptNumber
     */
    public DeptQuery deptNumber(String deptNumber){
        setDeptNumber(deptNumber);
        return this;
    }

    /**
     * 设置 部门编号
     * @param deptNumberList
     */
    public DeptQuery deptNumberList(List<String> deptNumberList){
        this.deptNumberList = deptNumberList;
        return this;
    }

    /**
     * 设置  填单机展示 (0.否，1.是)
     * @param isAutotable
     */
    public DeptQuery isAutotable(Integer isAutotable){
        setIsAutotable(isAutotable);
        return this;
    }

    /**
     * 设置 开始 填单机展示 (0.否，1.是)
     * @param isAutotableStart
     */
    public DeptQuery isAutotableStart(Integer isAutotableStart){
        this.isAutotableStart = isAutotableStart;
        return this;
    }

    /**
     * 设置 结束 填单机展示 (0.否，1.是)
     * @param isAutotableEnd
     */
    public DeptQuery isAutotableEnd(Integer isAutotableEnd){
        this.isAutotableEnd = isAutotableEnd;
        return this;
    }

    /**
     * 设置 增加 填单机展示 (0.否，1.是)
     * @param isAutotableIncrement
     */
    public DeptQuery isAutotableIncrement(Integer isAutotableIncrement){
        this.isAutotableIncrement = isAutotableIncrement;
        return this;
    }

    /**
     * 设置 填单机展示 (0.否，1.是)
     * @param isAutotableList
     */
    public DeptQuery isAutotableList(List<Integer> isAutotableList){
        this.isAutotableList = isAutotableList;
        return this;
    }

    /**
     * 设置 填单机展示 (0.否，1.是)
     * @param isAutotableNotList
     */
    public DeptQuery isAutotableNotList(List<Integer> isAutotableNotList){
        this.isAutotableNotList = isAutotableNotList;
        return this;
    }

    /**
     * 设置  预约展示 (0.否，1.是)
     * @param isOrder
     */
    public DeptQuery isOrder(Integer isOrder){
        setIsOrder(isOrder);
        return this;
    }

    /**
     * 设置 开始 预约展示 (0.否，1.是)
     * @param isOrderStart
     */
    public DeptQuery isOrderStart(Integer isOrderStart){
        this.isOrderStart = isOrderStart;
        return this;
    }

    /**
     * 设置 结束 预约展示 (0.否，1.是)
     * @param isOrderEnd
     */
    public DeptQuery isOrderEnd(Integer isOrderEnd){
        this.isOrderEnd = isOrderEnd;
        return this;
    }

    /**
     * 设置 增加 预约展示 (0.否，1.是)
     * @param isOrderIncrement
     */
    public DeptQuery isOrderIncrement(Integer isOrderIncrement){
        this.isOrderIncrement = isOrderIncrement;
        return this;
    }

    /**
     * 设置 预约展示 (0.否，1.是)
     * @param isOrderList
     */
    public DeptQuery isOrderList(List<Integer> isOrderList){
        this.isOrderList = isOrderList;
        return this;
    }

    /**
     * 设置 预约展示 (0.否，1.是)
     * @param isOrderNotList
     */
    public DeptQuery isOrderNotList(List<Integer> isOrderNotList){
        this.isOrderNotList = isOrderNotList;
        return this;
    }

    /**
     * 设置  背靠背展示 (0.否，1.是)
     * @param isBkb
     */
    public DeptQuery isBkb(Integer isBkb){
        setIsBkb(isBkb);
        return this;
    }

    /**
     * 设置 开始 背靠背展示 (0.否，1.是)
     * @param isBkbStart
     */
    public DeptQuery isBkbStart(Integer isBkbStart){
        this.isBkbStart = isBkbStart;
        return this;
    }

    /**
     * 设置 结束 背靠背展示 (0.否，1.是)
     * @param isBkbEnd
     */
    public DeptQuery isBkbEnd(Integer isBkbEnd){
        this.isBkbEnd = isBkbEnd;
        return this;
    }

    /**
     * 设置 增加 背靠背展示 (0.否，1.是)
     * @param isBkbIncrement
     */
    public DeptQuery isBkbIncrement(Integer isBkbIncrement){
        this.isBkbIncrement = isBkbIncrement;
        return this;
    }

    /**
     * 设置 背靠背展示 (0.否，1.是)
     * @param isBkbList
     */
    public DeptQuery isBkbList(List<Integer> isBkbList){
        this.isBkbList = isBkbList;
        return this;
    }

    /**
     * 设置 背靠背展示 (0.否，1.是)
     * @param isBkbNotList
     */
    public DeptQuery isBkbNotList(List<Integer> isBkbNotList){
        this.isBkbNotList = isBkbNotList;
        return this;
    }

    /**
     * 设置  办事指南展示 (0.否，1.是)
     * @param isWorkGuide
     */
    public DeptQuery isWorkGuide(Integer isWorkGuide){
        setIsWorkGuide(isWorkGuide);
        return this;
    }

    /**
     * 设置 开始 办事指南展示 (0.否，1.是)
     * @param isWorkGuideStart
     */
    public DeptQuery isWorkGuideStart(Integer isWorkGuideStart){
        this.isWorkGuideStart = isWorkGuideStart;
        return this;
    }

    /**
     * 设置 结束 办事指南展示 (0.否，1.是)
     * @param isWorkGuideEnd
     */
    public DeptQuery isWorkGuideEnd(Integer isWorkGuideEnd){
        this.isWorkGuideEnd = isWorkGuideEnd;
        return this;
    }

    /**
     * 设置 增加 办事指南展示 (0.否，1.是)
     * @param isWorkGuideIncrement
     */
    public DeptQuery isWorkGuideIncrement(Integer isWorkGuideIncrement){
        this.isWorkGuideIncrement = isWorkGuideIncrement;
        return this;
    }

    /**
     * 设置 办事指南展示 (0.否，1.是)
     * @param isWorkGuideList
     */
    public DeptQuery isWorkGuideList(List<Integer> isWorkGuideList){
        this.isWorkGuideList = isWorkGuideList;
        return this;
    }

    /**
     * 设置 办事指南展示 (0.否，1.是)
     * @param isWorkGuideNotList
     */
    public DeptQuery isWorkGuideNotList(List<Integer> isWorkGuideNotList){
        this.isWorkGuideNotList = isWorkGuideNotList;
        return this;
    }

    /**
     * 设置  是否使用 (0.否，1.是)
     * @param usValid
     */
    public DeptQuery usValid(Integer usValid){
        setUsValid(usValid);
        return this;
    }

    /**
     * 设置 开始 是否使用 (0.否，1.是)
     * @param usValidStart
     */
    public DeptQuery usValidStart(Integer usValidStart){
        this.usValidStart = usValidStart;
        return this;
    }

    /**
     * 设置 结束 是否使用 (0.否，1.是)
     * @param usValidEnd
     */
    public DeptQuery usValidEnd(Integer usValidEnd){
        this.usValidEnd = usValidEnd;
        return this;
    }

    /**
     * 设置 增加 是否使用 (0.否，1.是)
     * @param usValidIncrement
     */
    public DeptQuery usValidIncrement(Integer usValidIncrement){
        this.usValidIncrement = usValidIncrement;
        return this;
    }

    /**
     * 设置 是否使用 (0.否，1.是)
     * @param usValidList
     */
    public DeptQuery usValidList(List<Integer> usValidList){
        this.usValidList = usValidList;
        return this;
    }

    /**
     * 设置 是否使用 (0.否，1.是)
     * @param usValidNotList
     */
    public DeptQuery usValidNotList(List<Integer> usValidNotList){
        this.usValidNotList = usValidNotList;
        return this;
    }

    /**
     * 设置  部门电话是否展示 (0.否，1.是)
     * @param isSecphone
     */
    public DeptQuery isSecphone(Integer isSecphone){
        setIsSecphone(isSecphone);
        return this;
    }

    /**
     * 设置 开始 部门电话是否展示 (0.否，1.是)
     * @param isSecphoneStart
     */
    public DeptQuery isSecphoneStart(Integer isSecphoneStart){
        this.isSecphoneStart = isSecphoneStart;
        return this;
    }

    /**
     * 设置 结束 部门电话是否展示 (0.否，1.是)
     * @param isSecphoneEnd
     */
    public DeptQuery isSecphoneEnd(Integer isSecphoneEnd){
        this.isSecphoneEnd = isSecphoneEnd;
        return this;
    }

    /**
     * 设置 增加 部门电话是否展示 (0.否，1.是)
     * @param isSecphoneIncrement
     */
    public DeptQuery isSecphoneIncrement(Integer isSecphoneIncrement){
        this.isSecphoneIncrement = isSecphoneIncrement;
        return this;
    }

    /**
     * 设置 部门电话是否展示 (0.否，1.是)
     * @param isSecphoneList
     */
    public DeptQuery isSecphoneList(List<Integer> isSecphoneList){
        this.isSecphoneList = isSecphoneList;
        return this;
    }

    /**
     * 设置 部门电话是否展示 (0.否，1.是)
     * @param isSecphoneNotList
     */
    public DeptQuery isSecphoneNotList(List<Integer> isSecphoneNotList){
        this.isSecphoneNotList = isSecphoneNotList;
        return this;
    }

    /**
     * 设置  是否展示英文 (0.否，1.是)
     * @param isEnglish
     */
    public DeptQuery isEnglish(Integer isEnglish){
        setIsEnglish(isEnglish);
        return this;
    }

    /**
     * 设置 开始 是否展示英文 (0.否，1.是)
     * @param isEnglishStart
     */
    public DeptQuery isEnglishStart(Integer isEnglishStart){
        this.isEnglishStart = isEnglishStart;
        return this;
    }

    /**
     * 设置 结束 是否展示英文 (0.否，1.是)
     * @param isEnglishEnd
     */
    public DeptQuery isEnglishEnd(Integer isEnglishEnd){
        this.isEnglishEnd = isEnglishEnd;
        return this;
    }

    /**
     * 设置 增加 是否展示英文 (0.否，1.是)
     * @param isEnglishIncrement
     */
    public DeptQuery isEnglishIncrement(Integer isEnglishIncrement){
        this.isEnglishIncrement = isEnglishIncrement;
        return this;
    }

    /**
     * 设置 是否展示英文 (0.否，1.是)
     * @param isEnglishList
     */
    public DeptQuery isEnglishList(List<Integer> isEnglishList){
        this.isEnglishList = isEnglishList;
        return this;
    }

    /**
     * 设置 是否展示英文 (0.否，1.是)
     * @param isEnglishNotList
     */
    public DeptQuery isEnglishNotList(List<Integer> isEnglishNotList){
        this.isEnglishNotList = isEnglishNotList;
        return this;
    }

    /**
     * 设置  排序
     * @param sort
     */
    public DeptQuery sort(Integer sort){
        setSort(sort);
        return this;
    }

    /**
     * 设置 开始 排序
     * @param sortStart
     */
    public DeptQuery sortStart(Integer sortStart){
        this.sortStart = sortStart;
        return this;
    }

    /**
     * 设置 结束 排序
     * @param sortEnd
     */
    public DeptQuery sortEnd(Integer sortEnd){
        this.sortEnd = sortEnd;
        return this;
    }

    /**
     * 设置 增加 排序
     * @param sortIncrement
     */
    public DeptQuery sortIncrement(Integer sortIncrement){
        this.sortIncrement = sortIncrement;
        return this;
    }

    /**
     * 设置 排序
     * @param sortList
     */
    public DeptQuery sortList(List<Integer> sortList){
        this.sortList = sortList;
        return this;
    }

    /**
     * 设置 排序
     * @param sortNotList
     */
    public DeptQuery sortNotList(List<Integer> sortNotList){
        this.sortNotList = sortNotList;
        return this;
    }

    /**
     * 设置  部门来源
     * @param source
     */
    public DeptQuery source(Integer source){
        setSource(source);
        return this;
    }

    /**
     * 设置 开始 部门来源
     * @param sourceStart
     */
    public DeptQuery sourceStart(Integer sourceStart){
        this.sourceStart = sourceStart;
        return this;
    }

    /**
     * 设置 结束 部门来源
     * @param sourceEnd
     */
    public DeptQuery sourceEnd(Integer sourceEnd){
        this.sourceEnd = sourceEnd;
        return this;
    }

    /**
     * 设置 增加 部门来源
     * @param sourceIncrement
     */
    public DeptQuery sourceIncrement(Integer sourceIncrement){
        this.sourceIncrement = sourceIncrement;
        return this;
    }

    /**
     * 设置 部门来源
     * @param sourceList
     */
    public DeptQuery sourceList(List<Integer> sourceList){
        this.sourceList = sourceList;
        return this;
    }

    /**
     * 设置 部门来源
     * @param sourceNotList
     */
    public DeptQuery sourceNotList(List<Integer> sourceNotList){
        this.sourceNotList = sourceNotList;
        return this;
    }

    /**
     * 设置  关联事项数量
     * @param total
     */
    public DeptQuery total(Integer total){
        setTotal(total);
        return this;
    }

    /**
     * 设置 开始 关联事项数量
     * @param totalStart
     */
    public DeptQuery totalStart(Integer totalStart){
        this.totalStart = totalStart;
        return this;
    }

    /**
     * 设置 结束 关联事项数量
     * @param totalEnd
     */
    public DeptQuery totalEnd(Integer totalEnd){
        this.totalEnd = totalEnd;
        return this;
    }

    /**
     * 设置 增加 关联事项数量
     * @param totalIncrement
     */
    public DeptQuery totalIncrement(Integer totalIncrement){
        this.totalIncrement = totalIncrement;
        return this;
    }

    /**
     * 设置 关联事项数量
     * @param totalList
     */
    public DeptQuery totalList(List<Integer> totalList){
        this.totalList = totalList;
        return this;
    }

    /**
     * 设置 关联事项数量
     * @param totalNotList
     */
    public DeptQuery totalNotList(List<Integer> totalNotList){
        this.totalNotList = totalNotList;
        return this;
    }

    /**
     * 设置  入驻事项数量
     * @param inNum
     */
    public DeptQuery inNum(Integer inNum){
        setInNum(inNum);
        return this;
    }

    /**
     * 设置 开始 入驻事项数量
     * @param inNumStart
     */
    public DeptQuery inNumStart(Integer inNumStart){
        this.inNumStart = inNumStart;
        return this;
    }

    /**
     * 设置 结束 入驻事项数量
     * @param inNumEnd
     */
    public DeptQuery inNumEnd(Integer inNumEnd){
        this.inNumEnd = inNumEnd;
        return this;
    }

    /**
     * 设置 增加 入驻事项数量
     * @param inNumIncrement
     */
    public DeptQuery inNumIncrement(Integer inNumIncrement){
        this.inNumIncrement = inNumIncrement;
        return this;
    }

    /**
     * 设置 入驻事项数量
     * @param inNumList
     */
    public DeptQuery inNumList(List<Integer> inNumList){
        this.inNumList = inNumList;
        return this;
    }

    /**
     * 设置 入驻事项数量
     * @param inNumNotList
     */
    public DeptQuery inNumNotList(List<Integer> inNumNotList){
        this.inNumNotList = inNumNotList;
        return this;
    }


    /**
     * 设置  创建用户
     * @param createUserId
     */
    public DeptQuery createUserId(Long createUserId){
        setCreateUserId(createUserId);
        return this;
    }

    /**
     * 设置 开始 创建用户
     * @param createUserIdStart
     */
    public DeptQuery createUserIdStart(Long createUserIdStart){
        this.createUserIdStart = createUserIdStart;
        return this;
    }

    /**
     * 设置 结束 创建用户
     * @param createUserIdEnd
     */
    public DeptQuery createUserIdEnd(Long createUserIdEnd){
        this.createUserIdEnd = createUserIdEnd;
        return this;
    }

    /**
     * 设置 增加 创建用户
     * @param createUserIdIncrement
     */
    public DeptQuery createUserIdIncrement(Long createUserIdIncrement){
        this.createUserIdIncrement = createUserIdIncrement;
        return this;
    }

    /**
     * 设置 创建用户
     * @param createUserIdList
     */
    public DeptQuery createUserIdList(List<Long> createUserIdList){
        this.createUserIdList = createUserIdList;
        return this;
    }

    /**
     * 设置 创建用户
     * @param createUserIdNotList
     */
    public DeptQuery 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
     */
    public List<DeptQuery> getOrConditionList(){
        return this.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<DeptQuery> orConditionList){
        this.orConditionList = orConditionList;
    }

    /**
     * 获取 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
     * @return andConditionList
     */
    public List<DeptQuery> getAndConditionList(){
        return this.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<DeptQuery> andConditionList){
        this.andConditionList = andConditionList;
    }

}