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

import java.util.List;
import com.mortals.xhx.module.demotree.model.DemotreeEntity;
/**
* 树信息查询对象
*
* @author zxfei
* @date 2021-11-26
*/
public class DemotreeQuery extends DemotreeEntity {
    /** 开始 ID，主键，自增长 */
    private Long idStart;

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

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

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

    /** 名称 */
    private List<String> treeNameList;

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

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

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

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

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

    /** 开始 排序字段 */
    private Integer orderNumStart;

    /** 结束 排序字段 */
    private Integer orderNumEnd;

    /** 增加 排序字段 */
    private Integer orderNumIncrement;

    /** 排序字段列表 */
    private List <Integer> orderNumList;

    /** 开始 状态 ，0，停用，1，正常 默认1 */
    private Integer statusStart;

    /** 结束 状态 ，0，停用，1，正常 默认1 */
    private Integer statusEnd;

    /** 增加 状态 ，0，停用，1，正常 默认1 */
    private Integer statusIncrement;

    /** 状态 ，0，停用，1，正常 默认1列表 */
    private List <Integer> statusList;

    /** 开始 变更时间 */
    private String updateTimeStart;

    /** 结束 变更时间 */
    private String updateTimeEnd;

    /** 变更用户loginName */
    private List<String> updateUserList;

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

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

    /** 创建用户loginName */
    private List<String> createUserList;

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

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

    public DemotreeQuery(){}

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

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

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

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

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

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

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

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

    /**
    * 获取 名称
    * @return treeNameList
    */
    public List<String> getTreeNameList(){
        return this.treeNameList;
    }

    /**
    * 设置 名称
    * @param treeNameList
    */
    public void setTreeNameList(List<String> treeNameList){
        this.treeNameList = treeNameList;
    }
    /**
    * 获取 开始 父级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;
    }
    /**
    * 获取 开始 排序字段
    * @return orderNumStart
    */
    public Integer getOrderNumStart(){
        return this.orderNumStart;
    }

    /**
    * 设置 开始 排序字段
    * @param orderNumStart
    */
    public void setOrderNumStart(Integer orderNumStart){
        this.orderNumStart = orderNumStart;
    }

    /**
    * 获取 结束 排序字段
    * @return $orderNumEnd
    */
    public Integer getOrderNumEnd(){
        return this.orderNumEnd;
    }

    /**
    * 设置 结束 排序字段
    * @param orderNumEnd
    */
    public void setOrderNumEnd(Integer orderNumEnd){
        this.orderNumEnd = orderNumEnd;
    }

    /**
    * 获取 增加 排序字段
    * @return orderNumIncrement
    */
    public Integer getOrderNumIncrement(){
        return this.orderNumIncrement;
    }

    /**
    * 设置 增加 排序字段
    * @param orderNumIncrement
    */
    public void setOrderNumIncrement(Integer orderNumIncrement){
        this.orderNumIncrement = orderNumIncrement;
    }

    /**
    * 获取 排序字段
    * @return orderNumList
    */
    public List<Integer> getOrderNumList(){
        return this.orderNumList;
    }

    /**
    * 设置 排序字段
    * @param orderNumList
    */
    public void setOrderNumList(List<Integer> orderNumList){
        this.orderNumList = orderNumList;
    }

    /**
    * 获取 开始 状态 ，0，停用，1，正常 默认1
    * @return statusStart
    */
    public Integer getStatusStart(){
        return this.statusStart;
    }

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

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

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

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

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

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

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

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

    /**
    * 获取 变更用户loginName
    * @return updateUserList
    */
    public List<String> getUpdateUserList(){
        return this.updateUserList;
    }

    /**
    * 设置 变更用户loginName
    * @param updateUserList
    */
    public void setUpdateUserList(List<String> updateUserList){
        this.updateUserList = updateUserList;
    }
    /**
    * 获取 开始 创建时间
    * @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;
    }

    /**
    * 获取 创建用户loginName
    * @return createUserList
    */
    public List<String> getCreateUserList(){
        return this.createUserList;
    }

    /**
    * 设置 创建用户loginName
    * @param createUserList
    */
    public void setCreateUserList(List<String> createUserList){
        this.createUserList = createUserList;
    }
    /**
    * 设置  ID，主键，自增长
    * @param id
    */
    public DemotreeQuery id(Long id){
	    setId(id);
		return this;
    }
	
	 /**
    * 设置 开始 ID，主键，自增长
    * @param idStart
    */
    public DemotreeQuery idStart(Long idStart){
		this.idStart = idStart;
		return this;
    }

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

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

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


	/**
    * 设置 名称
    * @param treeName
    */
    public DemotreeQuery treeName(String treeName){
        setTreeName(treeName);
		return this;
    }

    /**
    * 设置 名称
    * @param treeNameList
    */
    public DemotreeQuery treeNameList(List<String> treeNameList){
        this.treeNameList = treeNameList;
		return this;
    }

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

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

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

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


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

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

    /**
    * 设置  排序字段
    * @param orderNum
    */
    public DemotreeQuery orderNum(Integer orderNum){
	    setOrderNum(orderNum);
		return this;
    }
	
	 /**
    * 设置 开始 排序字段
    * @param orderNumStart
    */
    public DemotreeQuery orderNumStart(Integer orderNumStart){
		this.orderNumStart = orderNumStart;
		return this;
    }

    /**
    * 设置 结束 排序字段
    * @param orderNumEnd
    */
    public DemotreeQuery orderNumEnd(Integer orderNumEnd){
		this.orderNumEnd = orderNumEnd;
		return this;
    }

    /**
    * 设置 增加 排序字段
    * @param orderNumIncrement
    */
    public DemotreeQuery orderNumIncrement(Integer orderNumIncrement){
		this.orderNumIncrement = orderNumIncrement;
		return this;
    }

    /**
    * 设置 排序字段
    * @param orderNumList
    */
    public DemotreeQuery orderNumList(List<Integer> orderNumList){
        this.orderNumList = orderNumList;
		return this;
        }

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

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

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

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



	/**
    * 设置 变更用户loginName
    * @param updateUser
    */
    public DemotreeQuery updateUser(String updateUser){
        setUpdateUser(updateUser);
		return this;
    }

    /**
    * 设置 变更用户loginName
    * @param updateUserList
    */
    public DemotreeQuery updateUserList(List<String> updateUserList){
        this.updateUserList = updateUserList;
		return this;
    }



	/**
    * 设置 创建用户loginName
    * @param createUser
    */
    public DemotreeQuery createUser(String createUser){
        setCreateUser(createUser);
		return this;
    }

    /**
    * 设置 创建用户loginName
    * @param createUserList
    */
    public DemotreeQuery createUserList(List<String> createUserList){
        this.createUserList = createUserList;
		return this;
    }

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

}