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

import java.util.List;
import com.mortals.xhx.module.business.model.BusinessEntity;
/**
* 站点业务查询对象
*
* @author zxfei
* @date 2022-01-13
*/
public class BusinessQuery extends BusinessEntity {
    /** 开始 序号，主键，自增长 */
    private Long idStart;

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

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

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

    /** 开始 父级ID */
    private Long parentIdStart;

    /** 结束 父级ID */
    private Long parentIdEnd;

    /** 增加 父级ID */
    private Long parentIdIncrement;

    /** 父级ID列表 */
    private List <Long> parentIdList;

    /** 祖级列表，逗号分隔 */
    private List<String> ancestorsList;

    /** 开始 业务类型(0.一级业务,1.二级业务) */
    private Integer isBusinessStart;

    /** 结束 业务类型(0.一级业务,1.二级业务) */
    private Integer isBusinessEnd;

    /** 增加 业务类型(0.一级业务,1.二级业务) */
    private Integer isBusinessIncrement;

    /** 业务类型(0.一级业务,1.二级业务)列表 */
    private List <Integer> isBusinessList;

    /** 业务名称 */
    private List<String> nameList;

    /** 备注 */
    private List<String> remarkList;

    /** 开始 是否允许预约（1.允许，0.不允许） */
    private Integer canorderStart;

    /** 结束 是否允许预约（1.允许，0.不允许） */
    private Integer canorderEnd;

    /** 增加 是否允许预约（1.允许，0.不允许） */
    private Integer canorderIncrement;

    /** 是否允许预约（1.允许，0.不允许）列表 */
    private List <Integer> canorderList;

    /** 开始 是否允许取号（1.允许，0.不允许） */
    private Integer cantakeStart;

    /** 结束 是否允许取号（1.允许，0.不允许） */
    private Integer cantakeEnd;

    /** 增加 是否允许取号（1.允许，0.不允许） */
    private Integer cantakeIncrement;

    /** 是否允许取号（1.允许，0.不允许）列表 */
    private List <Integer> cantakeList;

    /** 开始 大厅情况展示 （1.展示，0.不展示） */
    private Integer datashowStart;

    /** 结束 大厅情况展示 （1.展示，0.不展示） */
    private Integer datashowEnd;

    /** 增加 大厅情况展示 （1.展示，0.不展示） */
    private Integer datashowIncrement;

    /** 大厅情况展示 （1.展示，0.不展示）列表 */
    private List <Integer> datashowList;

    /** 英语业务名 */
    private List<String> englishnameList;

    /** 流水编号如A、B */
    private List<String> flownumList;

    /** 开始 业务状态 (0.停用，1.正常) */
    private Integer statusStart;

    /** 结束 业务状态 (0.停用，1.正常) */
    private Integer statusEnd;

    /** 增加 业务状态 (0.停用，1.正常) */
    private Integer statusIncrement;

    /** 业务状态 (0.停用，1.正常)列表 */
    private List <Integer> statusList;

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

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

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

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

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

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

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

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

    /** 开始 业务类型 (0.一体化业务，1.自建业务) */
    private Integer businessTypeStart;

    /** 结束 业务类型 (0.一体化业务，1.自建业务) */
    private Integer businessTypeEnd;

    /** 增加 业务类型 (0.一体化业务，1.自建业务) */
    private Integer businessTypeIncrement;

    /** 业务类型 (0.一体化业务，1.自建业务)列表 */
    private List <Integer> businessTypeList;

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

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

    public BusinessQuery(){}

    /**
    * 获取 开始 序号，主键，自增长
    * @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;
    }

    /**
    * 获取 开始 父级ID
    * @return parentIdStart
    */
    public Long getParentIdStart(){
        return this.parentIdStart;
    }

    /**
    * 设置 开始 父级ID
    * @param parentIdStart
    */
    public void setParentIdStart(Long parentIdStart){
        this.parentIdStart = parentIdStart;
    }

    /**
    * 获取 结束 父级ID
    * @return $parentIdEnd
    */
    public Long getParentIdEnd(){
        return this.parentIdEnd;
    }

    /**
    * 设置 结束 父级ID
    * @param parentIdEnd
    */
    public void setParentIdEnd(Long parentIdEnd){
        this.parentIdEnd = parentIdEnd;
    }

    /**
    * 获取 增加 父级ID
    * @return parentIdIncrement
    */
    public Long getParentIdIncrement(){
        return this.parentIdIncrement;
    }

    /**
    * 设置 增加 父级ID
    * @param parentIdIncrement
    */
    public void setParentIdIncrement(Long parentIdIncrement){
        this.parentIdIncrement = parentIdIncrement;
    }

    /**
    * 获取 父级ID
    * @return parentIdList
    */
    public List<Long> getParentIdList(){
        return this.parentIdList;
    }

    /**
    * 设置 父级ID
    * @param parentIdList
    */
    public void setParentIdList(List<Long> parentIdList){
        this.parentIdList = parentIdList;
    }

    /**
    * 获取 祖级列表，逗号分隔
    * @return ancestorsList
    */
    public List<String> getAncestorsList(){
        return this.ancestorsList;
    }

    /**
    * 设置 祖级列表，逗号分隔
    * @param ancestorsList
    */
    public void setAncestorsList(List<String> ancestorsList){
        this.ancestorsList = ancestorsList;
    }
    /**
    * 获取 开始 业务类型(0.一级业务,1.二级业务)
    * @return isBusinessStart
    */
    public Integer getIsBusinessStart(){
        return this.isBusinessStart;
    }

    /**
    * 设置 开始 业务类型(0.一级业务,1.二级业务)
    * @param isBusinessStart
    */
    public void setIsBusinessStart(Integer isBusinessStart){
        this.isBusinessStart = isBusinessStart;
    }

    /**
    * 获取 结束 业务类型(0.一级业务,1.二级业务)
    * @return $isBusinessEnd
    */
    public Integer getIsBusinessEnd(){
        return this.isBusinessEnd;
    }

    /**
    * 设置 结束 业务类型(0.一级业务,1.二级业务)
    * @param isBusinessEnd
    */
    public void setIsBusinessEnd(Integer isBusinessEnd){
        this.isBusinessEnd = isBusinessEnd;
    }

    /**
    * 获取 增加 业务类型(0.一级业务,1.二级业务)
    * @return isBusinessIncrement
    */
    public Integer getIsBusinessIncrement(){
        return this.isBusinessIncrement;
    }

    /**
    * 设置 增加 业务类型(0.一级业务,1.二级业务)
    * @param isBusinessIncrement
    */
    public void setIsBusinessIncrement(Integer isBusinessIncrement){
        this.isBusinessIncrement = isBusinessIncrement;
    }

    /**
    * 获取 业务类型(0.一级业务,1.二级业务)
    * @return isBusinessList
    */
    public List<Integer> getIsBusinessList(){
        return this.isBusinessList;
    }

    /**
    * 设置 业务类型(0.一级业务,1.二级业务)
    * @param isBusinessList
    */
    public void setIsBusinessList(List<Integer> isBusinessList){
        this.isBusinessList = isBusinessList;
    }

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

    /**
    * 设置 业务名称
    * @param nameList
    */
    public void setNameList(List<String> nameList){
        this.nameList = nameList;
    }
    /**
    * 获取 备注
    * @return remarkList
    */
    public List<String> getRemarkList(){
        return this.remarkList;
    }

    /**
    * 设置 备注
    * @param remarkList
    */
    public void setRemarkList(List<String> remarkList){
        this.remarkList = remarkList;
    }
    /**
    * 获取 开始 是否允许预约（1.允许，0.不允许）
    * @return canorderStart
    */
    public Integer getCanorderStart(){
        return this.canorderStart;
    }

    /**
    * 设置 开始 是否允许预约（1.允许，0.不允许）
    * @param canorderStart
    */
    public void setCanorderStart(Integer canorderStart){
        this.canorderStart = canorderStart;
    }

    /**
    * 获取 结束 是否允许预约（1.允许，0.不允许）
    * @return $canorderEnd
    */
    public Integer getCanorderEnd(){
        return this.canorderEnd;
    }

    /**
    * 设置 结束 是否允许预约（1.允许，0.不允许）
    * @param canorderEnd
    */
    public void setCanorderEnd(Integer canorderEnd){
        this.canorderEnd = canorderEnd;
    }

    /**
    * 获取 增加 是否允许预约（1.允许，0.不允许）
    * @return canorderIncrement
    */
    public Integer getCanorderIncrement(){
        return this.canorderIncrement;
    }

    /**
    * 设置 增加 是否允许预约（1.允许，0.不允许）
    * @param canorderIncrement
    */
    public void setCanorderIncrement(Integer canorderIncrement){
        this.canorderIncrement = canorderIncrement;
    }

    /**
    * 获取 是否允许预约（1.允许，0.不允许）
    * @return canorderList
    */
    public List<Integer> getCanorderList(){
        return this.canorderList;
    }

    /**
    * 设置 是否允许预约（1.允许，0.不允许）
    * @param canorderList
    */
    public void setCanorderList(List<Integer> canorderList){
        this.canorderList = canorderList;
    }

    /**
    * 获取 开始 是否允许取号（1.允许，0.不允许）
    * @return cantakeStart
    */
    public Integer getCantakeStart(){
        return this.cantakeStart;
    }

    /**
    * 设置 开始 是否允许取号（1.允许，0.不允许）
    * @param cantakeStart
    */
    public void setCantakeStart(Integer cantakeStart){
        this.cantakeStart = cantakeStart;
    }

    /**
    * 获取 结束 是否允许取号（1.允许，0.不允许）
    * @return $cantakeEnd
    */
    public Integer getCantakeEnd(){
        return this.cantakeEnd;
    }

    /**
    * 设置 结束 是否允许取号（1.允许，0.不允许）
    * @param cantakeEnd
    */
    public void setCantakeEnd(Integer cantakeEnd){
        this.cantakeEnd = cantakeEnd;
    }

    /**
    * 获取 增加 是否允许取号（1.允许，0.不允许）
    * @return cantakeIncrement
    */
    public Integer getCantakeIncrement(){
        return this.cantakeIncrement;
    }

    /**
    * 设置 增加 是否允许取号（1.允许，0.不允许）
    * @param cantakeIncrement
    */
    public void setCantakeIncrement(Integer cantakeIncrement){
        this.cantakeIncrement = cantakeIncrement;
    }

    /**
    * 获取 是否允许取号（1.允许，0.不允许）
    * @return cantakeList
    */
    public List<Integer> getCantakeList(){
        return this.cantakeList;
    }

    /**
    * 设置 是否允许取号（1.允许，0.不允许）
    * @param cantakeList
    */
    public void setCantakeList(List<Integer> cantakeList){
        this.cantakeList = cantakeList;
    }

    /**
    * 获取 开始 大厅情况展示 （1.展示，0.不展示）
    * @return datashowStart
    */
    public Integer getDatashowStart(){
        return this.datashowStart;
    }

    /**
    * 设置 开始 大厅情况展示 （1.展示，0.不展示）
    * @param datashowStart
    */
    public void setDatashowStart(Integer datashowStart){
        this.datashowStart = datashowStart;
    }

    /**
    * 获取 结束 大厅情况展示 （1.展示，0.不展示）
    * @return $datashowEnd
    */
    public Integer getDatashowEnd(){
        return this.datashowEnd;
    }

    /**
    * 设置 结束 大厅情况展示 （1.展示，0.不展示）
    * @param datashowEnd
    */
    public void setDatashowEnd(Integer datashowEnd){
        this.datashowEnd = datashowEnd;
    }

    /**
    * 获取 增加 大厅情况展示 （1.展示，0.不展示）
    * @return datashowIncrement
    */
    public Integer getDatashowIncrement(){
        return this.datashowIncrement;
    }

    /**
    * 设置 增加 大厅情况展示 （1.展示，0.不展示）
    * @param datashowIncrement
    */
    public void setDatashowIncrement(Integer datashowIncrement){
        this.datashowIncrement = datashowIncrement;
    }

    /**
    * 获取 大厅情况展示 （1.展示，0.不展示）
    * @return datashowList
    */
    public List<Integer> getDatashowList(){
        return this.datashowList;
    }

    /**
    * 设置 大厅情况展示 （1.展示，0.不展示）
    * @param datashowList
    */
    public void setDatashowList(List<Integer> datashowList){
        this.datashowList = datashowList;
    }

    /**
    * 获取 英语业务名
    * @return englishnameList
    */
    public List<String> getEnglishnameList(){
        return this.englishnameList;
    }

    /**
    * 设置 英语业务名
    * @param englishnameList
    */
    public void setEnglishnameList(List<String> englishnameList){
        this.englishnameList = englishnameList;
    }
    /**
    * 获取 流水编号如A、B
    * @return flownumList
    */
    public List<String> getFlownumList(){
        return this.flownumList;
    }

    /**
    * 设置 流水编号如A、B
    * @param flownumList
    */
    public void setFlownumList(List<String> flownumList){
        this.flownumList = flownumList;
    }
    /**
    * 获取 开始 业务状态 (0.停用，1.正常)
    * @return statusStart
    */
    public Integer getStatusStart(){
        return this.statusStart;
    }

    /**
    * 设置 开始 业务状态 (0.停用，1.正常)
    * @param statusStart
    */
    public void setStatusStart(Integer statusStart){
        this.statusStart = statusStart;
    }

    /**
    * 获取 结束 业务状态 (0.停用，1.正常)
    * @return $statusEnd
    */
    public Integer getStatusEnd(){
        return this.statusEnd;
    }

    /**
    * 设置 结束 业务状态 (0.停用，1.正常)
    * @param statusEnd
    */
    public void setStatusEnd(Integer statusEnd){
        this.statusEnd = statusEnd;
    }

    /**
    * 获取 增加 业务状态 (0.停用，1.正常)
    * @return statusIncrement
    */
    public Integer getStatusIncrement(){
        return this.statusIncrement;
    }

    /**
    * 设置 增加 业务状态 (0.停用，1.正常)
    * @param statusIncrement
    */
    public void setStatusIncrement(Integer statusIncrement){
        this.statusIncrement = statusIncrement;
    }

    /**
    * 获取 业务状态 (0.停用，1.正常)
    * @return statusList
    */
    public List<Integer> getStatusList(){
        return this.statusList;
    }

    /**
    * 设置 业务状态 (0.停用，1.正常)
    * @param statusList
    */
    public void setStatusList(List<Integer> statusList){
        this.statusList = statusList;
    }

    /**
    * 获取 开始 创建时间
    * @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 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;
    }

    /**
    * 获取 开始 业务类型 (0.一体化业务，1.自建业务)
    * @return businessTypeStart
    */
    public Integer getBusinessTypeStart(){
        return this.businessTypeStart;
    }

    /**
    * 设置 开始 业务类型 (0.一体化业务，1.自建业务)
    * @param businessTypeStart
    */
    public void setBusinessTypeStart(Integer businessTypeStart){
        this.businessTypeStart = businessTypeStart;
    }

    /**
    * 获取 结束 业务类型 (0.一体化业务，1.自建业务)
    * @return $businessTypeEnd
    */
    public Integer getBusinessTypeEnd(){
        return this.businessTypeEnd;
    }

    /**
    * 设置 结束 业务类型 (0.一体化业务，1.自建业务)
    * @param businessTypeEnd
    */
    public void setBusinessTypeEnd(Integer businessTypeEnd){
        this.businessTypeEnd = businessTypeEnd;
    }

    /**
    * 获取 增加 业务类型 (0.一体化业务，1.自建业务)
    * @return businessTypeIncrement
    */
    public Integer getBusinessTypeIncrement(){
        return this.businessTypeIncrement;
    }

    /**
    * 设置 增加 业务类型 (0.一体化业务，1.自建业务)
    * @param businessTypeIncrement
    */
    public void setBusinessTypeIncrement(Integer businessTypeIncrement){
        this.businessTypeIncrement = businessTypeIncrement;
    }

    /**
    * 获取 业务类型 (0.一体化业务，1.自建业务)
    * @return businessTypeList
    */
    public List<Integer> getBusinessTypeList(){
        return this.businessTypeList;
    }

    /**
    * 设置 业务类型 (0.一体化业务，1.自建业务)
    * @param businessTypeList
    */
    public void setBusinessTypeList(List<Integer> businessTypeList){
        this.businessTypeList = businessTypeList;
    }

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

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

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

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

    /**
    * 设置  父级ID
    * @param parentId
    */
    public BusinessQuery parentId(Long parentId){
	    setParentId(parentId);
		return this;
    }
	
	 /**
    * 设置 开始 父级ID
    * @param parentIdStart
    */
    public BusinessQuery parentIdStart(Long parentIdStart){
		this.parentIdStart = parentIdStart;
		return this;
    }

    /**
    * 设置 结束 父级ID
    * @param parentIdEnd
    */
    public BusinessQuery parentIdEnd(Long parentIdEnd){
		this.parentIdEnd = parentIdEnd;
		return this;
    }

    /**
    * 设置 增加 父级ID
    * @param parentIdIncrement
    */
    public BusinessQuery parentIdIncrement(Long parentIdIncrement){
		this.parentIdIncrement = parentIdIncrement;
		return this;
    }

    /**
    * 设置 父级ID
    * @param parentIdList
    */
    public BusinessQuery parentIdList(List<Long> parentIdList){
        this.parentIdList = parentIdList;
		return this;
        }


	/**
    * 设置 祖级列表，逗号分隔
    * @param ancestors
    */
    public BusinessQuery ancestors(String ancestors){
        setAncestors(ancestors);
		return this;
    }

    /**
    * 设置 祖级列表，逗号分隔
    * @param ancestorsList
    */
    public BusinessQuery ancestorsList(List<String> ancestorsList){
        this.ancestorsList = ancestorsList;
		return this;
    }

    /**
    * 设置  业务类型(0.一级业务,1.二级业务)
    * @param isBusiness
    */
    public BusinessQuery isBusiness(Integer isBusiness){
	    setIsBusiness(isBusiness);
		return this;
    }
	
	 /**
    * 设置 开始 业务类型(0.一级业务,1.二级业务)
    * @param isBusinessStart
    */
    public BusinessQuery isBusinessStart(Integer isBusinessStart){
		this.isBusinessStart = isBusinessStart;
		return this;
    }

    /**
    * 设置 结束 业务类型(0.一级业务,1.二级业务)
    * @param isBusinessEnd
    */
    public BusinessQuery isBusinessEnd(Integer isBusinessEnd){
		this.isBusinessEnd = isBusinessEnd;
		return this;
    }

    /**
    * 设置 增加 业务类型(0.一级业务,1.二级业务)
    * @param isBusinessIncrement
    */
    public BusinessQuery isBusinessIncrement(Integer isBusinessIncrement){
		this.isBusinessIncrement = isBusinessIncrement;
		return this;
    }

    /**
    * 设置 业务类型(0.一级业务,1.二级业务)
    * @param isBusinessList
    */
    public BusinessQuery isBusinessList(List<Integer> isBusinessList){
        this.isBusinessList = isBusinessList;
		return this;
        }


	/**
    * 设置 业务名称
    * @param name
    */
    public BusinessQuery name(String name){
        setName(name);
		return this;
    }

    /**
    * 设置 业务名称
    * @param nameList
    */
    public BusinessQuery nameList(List<String> nameList){
        this.nameList = nameList;
		return this;
    }


	/**
    * 设置 备注
    * @param remark
    */
    public BusinessQuery remark(String remark){
        setRemark(remark);
		return this;
    }

    /**
    * 设置 备注
    * @param remarkList
    */
    public BusinessQuery remarkList(List<String> remarkList){
        this.remarkList = remarkList;
		return this;
    }

    /**
    * 设置  是否允许预约（1.允许，0.不允许）
    * @param canorder
    */
    public BusinessQuery canorder(Integer canorder){
	    setCanorder(canorder);
		return this;
    }
	
	 /**
    * 设置 开始 是否允许预约（1.允许，0.不允许）
    * @param canorderStart
    */
    public BusinessQuery canorderStart(Integer canorderStart){
		this.canorderStart = canorderStart;
		return this;
    }

    /**
    * 设置 结束 是否允许预约（1.允许，0.不允许）
    * @param canorderEnd
    */
    public BusinessQuery canorderEnd(Integer canorderEnd){
		this.canorderEnd = canorderEnd;
		return this;
    }

    /**
    * 设置 增加 是否允许预约（1.允许，0.不允许）
    * @param canorderIncrement
    */
    public BusinessQuery canorderIncrement(Integer canorderIncrement){
		this.canorderIncrement = canorderIncrement;
		return this;
    }

    /**
    * 设置 是否允许预约（1.允许，0.不允许）
    * @param canorderList
    */
    public BusinessQuery canorderList(List<Integer> canorderList){
        this.canorderList = canorderList;
		return this;
        }

    /**
    * 设置  是否允许取号（1.允许，0.不允许）
    * @param cantake
    */
    public BusinessQuery cantake(Integer cantake){
	    setCantake(cantake);
		return this;
    }
	
	 /**
    * 设置 开始 是否允许取号（1.允许，0.不允许）
    * @param cantakeStart
    */
    public BusinessQuery cantakeStart(Integer cantakeStart){
		this.cantakeStart = cantakeStart;
		return this;
    }

    /**
    * 设置 结束 是否允许取号（1.允许，0.不允许）
    * @param cantakeEnd
    */
    public BusinessQuery cantakeEnd(Integer cantakeEnd){
		this.cantakeEnd = cantakeEnd;
		return this;
    }

    /**
    * 设置 增加 是否允许取号（1.允许，0.不允许）
    * @param cantakeIncrement
    */
    public BusinessQuery cantakeIncrement(Integer cantakeIncrement){
		this.cantakeIncrement = cantakeIncrement;
		return this;
    }

    /**
    * 设置 是否允许取号（1.允许，0.不允许）
    * @param cantakeList
    */
    public BusinessQuery cantakeList(List<Integer> cantakeList){
        this.cantakeList = cantakeList;
		return this;
        }

    /**
    * 设置  大厅情况展示 （1.展示，0.不展示）
    * @param datashow
    */
    public BusinessQuery datashow(Integer datashow){
	    setDatashow(datashow);
		return this;
    }
	
	 /**
    * 设置 开始 大厅情况展示 （1.展示，0.不展示）
    * @param datashowStart
    */
    public BusinessQuery datashowStart(Integer datashowStart){
		this.datashowStart = datashowStart;
		return this;
    }

    /**
    * 设置 结束 大厅情况展示 （1.展示，0.不展示）
    * @param datashowEnd
    */
    public BusinessQuery datashowEnd(Integer datashowEnd){
		this.datashowEnd = datashowEnd;
		return this;
    }

    /**
    * 设置 增加 大厅情况展示 （1.展示，0.不展示）
    * @param datashowIncrement
    */
    public BusinessQuery datashowIncrement(Integer datashowIncrement){
		this.datashowIncrement = datashowIncrement;
		return this;
    }

    /**
    * 设置 大厅情况展示 （1.展示，0.不展示）
    * @param datashowList
    */
    public BusinessQuery datashowList(List<Integer> datashowList){
        this.datashowList = datashowList;
		return this;
        }


	/**
    * 设置 英语业务名
    * @param englishname
    */
    public BusinessQuery englishname(String englishname){
        setEnglishname(englishname);
		return this;
    }

    /**
    * 设置 英语业务名
    * @param englishnameList
    */
    public BusinessQuery englishnameList(List<String> englishnameList){
        this.englishnameList = englishnameList;
		return this;
    }


	/**
    * 设置 流水编号如A、B
    * @param flownum
    */
    public BusinessQuery flownum(String flownum){
        setFlownum(flownum);
		return this;
    }

    /**
    * 设置 流水编号如A、B
    * @param flownumList
    */
    public BusinessQuery flownumList(List<String> flownumList){
        this.flownumList = flownumList;
		return this;
    }

    /**
    * 设置  业务状态 (0.停用，1.正常)
    * @param status
    */
    public BusinessQuery status(Integer status){
	    setStatus(status);
		return this;
    }
	
	 /**
    * 设置 开始 业务状态 (0.停用，1.正常)
    * @param statusStart
    */
    public BusinessQuery statusStart(Integer statusStart){
		this.statusStart = statusStart;
		return this;
    }

    /**
    * 设置 结束 业务状态 (0.停用，1.正常)
    * @param statusEnd
    */
    public BusinessQuery statusEnd(Integer statusEnd){
		this.statusEnd = statusEnd;
		return this;
    }

    /**
    * 设置 增加 业务状态 (0.停用，1.正常)
    * @param statusIncrement
    */
    public BusinessQuery statusIncrement(Integer statusIncrement){
		this.statusIncrement = statusIncrement;
		return this;
    }

    /**
    * 设置 业务状态 (0.停用，1.正常)
    * @param statusList
    */
    public BusinessQuery statusList(List<Integer> statusList){
        this.statusList = statusList;
		return this;
        }


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

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

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

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


    /**
    * 设置  业务类型 (0.一体化业务，1.自建业务)
    * @param businessType
    */
    public BusinessQuery businessType(Integer businessType){
	    setBusinessType(businessType);
		return this;
    }
	
	 /**
    * 设置 开始 业务类型 (0.一体化业务，1.自建业务)
    * @param businessTypeStart
    */
    public BusinessQuery businessTypeStart(Integer businessTypeStart){
		this.businessTypeStart = businessTypeStart;
		return this;
    }

    /**
    * 设置 结束 业务类型 (0.一体化业务，1.自建业务)
    * @param businessTypeEnd
    */
    public BusinessQuery businessTypeEnd(Integer businessTypeEnd){
		this.businessTypeEnd = businessTypeEnd;
		return this;
    }

    /**
    * 设置 增加 业务类型 (0.一体化业务，1.自建业务)
    * @param businessTypeIncrement
    */
    public BusinessQuery businessTypeIncrement(Integer businessTypeIncrement){
		this.businessTypeIncrement = businessTypeIncrement;
		return this;
    }

    /**
    * 设置 业务类型 (0.一体化业务，1.自建业务)
    * @param businessTypeList
    */
    public BusinessQuery businessTypeList(List<Integer> businessTypeList){
        this.businessTypeList = businessTypeList;
		return this;
        }

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

}