/**
* 文件：TaskQuery.java
* 版本：1.0.0
* 日期：
* Copyright &reg; 
* All right reserved.
*/

package com.mortals.xhx.base.system.task.model;
import java.util.List;
/**
 * <p>Title: 任务信息</p>
 * <p>Description: TaskQuery  </p>
 * <p>Copyright: Copyright &reg;  </p>
 * <p>Company: </p>
 * @author 
 * @version 1.0.0
 */
public class TaskQuery extends TaskEntity{
	private static final long serialVersionUID = 1547777703373L;
	/** 开始 序号，主键，自增长 */
	private Long idStart;

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

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

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

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

	/** 任务关键字，区分任务执行流程 */
	private List<String> taskKeyList;

	/** 开始 任务状态，0：未启动，1：执行中，默认0 */
	private Integer statusStart;

	/** 结束 任务状态，0：未启动，1：执行中，默认0 */
	private Integer statusEnd;

	/** 增加 任务状态，0：未启动，1：执行中，默认0 */
	private Integer statusIncrement;

	/** 任务状态，0：未启动，1：执行中，默认0 */
	private List<Integer> statusList;

	/** 任务执行服务 */
	private List<String> excuteServiceList;

	/** 任务执行参数 */
	private List<String> excuteParamList;

	/** 任务执行主机，为空表示不限制任务的执行主机，多个用逗号分隔 */
	private List<String> excuteHostList;

	/** 开始 执行策略，1：按日，2：按周，3：按月，4：按间隔时间，默认1 */
	private Integer excuteStrategyStart;

	/** 结束 执行策略，1：按日，2：按周，3：按月，4：按间隔时间，默认1 */
	private Integer excuteStrategyEnd;

	/** 增加 执行策略，1：按日，2：按周，3：按月，4：按间隔时间，默认1 */
	private Integer excuteStrategyIncrement;

	/** 执行策略，1：按日，2：按周，3：按月，4：按间隔时间，默认1 */
	private List<Integer> excuteStrategyList;

	/** 开始 执行日期，按日：则为0；按周：则为1-7；按月：则为：1-31；按间隔时间：则为间隔时间，单位：秒；默认0 */
	private Integer excuteDateStart;

	/** 结束 执行日期，按日：则为0；按周：则为1-7；按月：则为：1-31；按间隔时间：则为间隔时间，单位：秒；默认0 */
	private Integer excuteDateEnd;

	/** 增加 执行日期，按日：则为0；按周：则为1-7；按月：则为：1-31；按间隔时间：则为间隔时间，单位：秒；默认0 */
	private Integer excuteDateIncrement;

	/** 执行日期，按日：则为0；按周：则为1-7；按月：则为：1-31；按间隔时间：则为间隔时间，单位：秒；默认0 */
	private List<Integer> excuteDateList;

	/** 执行时间，格式：HH:mm，默认：00:00 */
	private List<String> excuteTimeList;

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

	/** 最后执行主机 */
	private List<String> lastExcuteHostList;

	/** 开始 最后执行时间 */
	private String lastExcuteTimeStart;

	/** 结束 最后执行时间 */
	private String lastExcuteTimeEnd;

	/** 开始 临时执行状态，0：未启用，1：立即执行并保留，2：立即执行并删除，默认0 */
	private Integer interimExcuteStatusStart;

	/** 结束 临时执行状态，0：未启用，1：立即执行并保留，2：立即执行并删除，默认0 */
	private Integer interimExcuteStatusEnd;

	/** 增加 临时执行状态，0：未启用，1：立即执行并保留，2：立即执行并删除，默认0 */
	private Integer interimExcuteStatusIncrement;

	/** 临时执行状态，0：未启用，1：立即执行并保留，2：立即执行并删除，默认0 */
	private List<Integer> interimExcuteStatusList;

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

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

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

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

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

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

	/** 创建用户名称 */
	private List<String> createUserNameList;


	public TaskQuery(){
	}
	/**
	 * 获取 开始 序号，主键，自增长
	 * @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 nameList
	 */
	public List<String> getNameList(){
		return this.nameList;
	}

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

	/**
	 * 获取 任务关键字，区分任务执行流程
	 * @return taskKeyList
	 */
	public List<String> getTaskKeyList(){
		return this.taskKeyList;
	}

	/**
	 * 设置 任务关键字，区分任务执行流程
	 * @param taskKeyList
	 */
	public void setTaskKeyList(List<String> taskKeyList){
		this.taskKeyList = taskKeyList;
	}

	/**
	 * 获取 开始 任务状态，0：未启动，1：执行中，默认0
	 * @return statusStart
	 */
	public Integer getStatusStart(){
		return this.statusStart;
	}

	/**
	 * 设置 开始 任务状态，0：未启动，1：执行中，默认0
	 * @param statusStart
	 */
	public void setStatusStart(Integer statusStart){
		this.statusStart = statusStart;
	}

	/**
	 * 获取 结束 任务状态，0：未启动，1：执行中，默认0
	 * @return statusEnd
	 */
	public Integer getStatusEnd(){
		return this.statusEnd;
	}

	/**
	 * 设置 结束 任务状态，0：未启动，1：执行中，默认0
	 * @param statusEnd
	 */
	public void setStatusEnd(Integer statusEnd){
		this.statusEnd = statusEnd;
	}

	/**
	 * 获取 增加 任务状态，0：未启动，1：执行中，默认0
	 * @return statusIncrement
	 */
	public Integer getStatusIncrement(){
		return this.statusIncrement;
	}

	/**
	 * 设置 增加 任务状态，0：未启动，1：执行中，默认0
	 * @param statusIncrement
	 */
	public void setStatusIncrement(Integer statusIncrement){
		this.statusIncrement = statusIncrement;
	}

	/**
	 * 获取 任务状态，0：未启动，1：执行中，默认0
	 * @return statusList
	 */
	public List<Integer> getStatusList(){
		return this.statusList;
	}

	/**
	 * 设置 任务状态，0：未启动，1：执行中，默认0
	 * @param statusList
	 */
	public void setStatusList(List<Integer> statusList){
		this.statusList = statusList;
	}

	/**
	 * 获取 任务执行服务
	 * @return excuteServiceList
	 */
	public List<String> getExcuteServiceList(){
		return this.excuteServiceList;
	}

	/**
	 * 设置 任务执行服务
	 * @param excuteServiceList
	 */
	public void setExcuteServiceList(List<String> excuteServiceList){
		this.excuteServiceList = excuteServiceList;
	}

	/**
	 * 获取 任务执行参数
	 * @return excuteParamList
	 */
	public List<String> getExcuteParamList(){
		return this.excuteParamList;
	}

	/**
	 * 设置 任务执行参数
	 * @param excuteParamList
	 */
	public void setExcuteParamList(List<String> excuteParamList){
		this.excuteParamList = excuteParamList;
	}

	/**
	 * 获取 任务执行主机，为空表示不限制任务的执行主机，多个用逗号分隔
	 * @return excuteHostList
	 */
	public List<String> getExcuteHostList(){
		return this.excuteHostList;
	}

	/**
	 * 设置 任务执行主机，为空表示不限制任务的执行主机，多个用逗号分隔
	 * @param excuteHostList
	 */
	public void setExcuteHostList(List<String> excuteHostList){
		this.excuteHostList = excuteHostList;
	}

	/**
	 * 获取 开始 执行策略，1：按日，2：按周，3：按月，4：按间隔时间，默认1
	 * @return excuteStrategyStart
	 */
	public Integer getExcuteStrategyStart(){
		return this.excuteStrategyStart;
	}

	/**
	 * 设置 开始 执行策略，1：按日，2：按周，3：按月，4：按间隔时间，默认1
	 * @param excuteStrategyStart
	 */
	public void setExcuteStrategyStart(Integer excuteStrategyStart){
		this.excuteStrategyStart = excuteStrategyStart;
	}

	/**
	 * 获取 结束 执行策略，1：按日，2：按周，3：按月，4：按间隔时间，默认1
	 * @return excuteStrategyEnd
	 */
	public Integer getExcuteStrategyEnd(){
		return this.excuteStrategyEnd;
	}

	/**
	 * 设置 结束 执行策略，1：按日，2：按周，3：按月，4：按间隔时间，默认1
	 * @param excuteStrategyEnd
	 */
	public void setExcuteStrategyEnd(Integer excuteStrategyEnd){
		this.excuteStrategyEnd = excuteStrategyEnd;
	}

	/**
	 * 获取 增加 执行策略，1：按日，2：按周，3：按月，4：按间隔时间，默认1
	 * @return excuteStrategyIncrement
	 */
	public Integer getExcuteStrategyIncrement(){
		return this.excuteStrategyIncrement;
	}

	/**
	 * 设置 增加 执行策略，1：按日，2：按周，3：按月，4：按间隔时间，默认1
	 * @param excuteStrategyIncrement
	 */
	public void setExcuteStrategyIncrement(Integer excuteStrategyIncrement){
		this.excuteStrategyIncrement = excuteStrategyIncrement;
	}

	/**
	 * 获取 执行策略，1：按日，2：按周，3：按月，4：按间隔时间，默认1
	 * @return excuteStrategyList
	 */
	public List<Integer> getExcuteStrategyList(){
		return this.excuteStrategyList;
	}

	/**
	 * 设置 执行策略，1：按日，2：按周，3：按月，4：按间隔时间，默认1
	 * @param excuteStrategyList
	 */
	public void setExcuteStrategyList(List<Integer> excuteStrategyList){
		this.excuteStrategyList = excuteStrategyList;
	}

	/**
	 * 获取 开始 执行日期，按日：则为0；按周：则为1-7；按月：则为：1-31；按间隔时间：则为间隔时间，单位：秒；默认0
	 * @return excuteDateStart
	 */
	public Integer getExcuteDateStart(){
		return this.excuteDateStart;
	}

	/**
	 * 设置 开始 执行日期，按日：则为0；按周：则为1-7；按月：则为：1-31；按间隔时间：则为间隔时间，单位：秒；默认0
	 * @param excuteDateStart
	 */
	public void setExcuteDateStart(Integer excuteDateStart){
		this.excuteDateStart = excuteDateStart;
	}

	/**
	 * 获取 结束 执行日期，按日：则为0；按周：则为1-7；按月：则为：1-31；按间隔时间：则为间隔时间，单位：秒；默认0
	 * @return excuteDateEnd
	 */
	public Integer getExcuteDateEnd(){
		return this.excuteDateEnd;
	}

	/**
	 * 设置 结束 执行日期，按日：则为0；按周：则为1-7；按月：则为：1-31；按间隔时间：则为间隔时间，单位：秒；默认0
	 * @param excuteDateEnd
	 */
	public void setExcuteDateEnd(Integer excuteDateEnd){
		this.excuteDateEnd = excuteDateEnd;
	}

	/**
	 * 获取 增加 执行日期，按日：则为0；按周：则为1-7；按月：则为：1-31；按间隔时间：则为间隔时间，单位：秒；默认0
	 * @return excuteDateIncrement
	 */
	public Integer getExcuteDateIncrement(){
		return this.excuteDateIncrement;
	}

	/**
	 * 设置 增加 执行日期，按日：则为0；按周：则为1-7；按月：则为：1-31；按间隔时间：则为间隔时间，单位：秒；默认0
	 * @param excuteDateIncrement
	 */
	public void setExcuteDateIncrement(Integer excuteDateIncrement){
		this.excuteDateIncrement = excuteDateIncrement;
	}

	/**
	 * 获取 执行日期，按日：则为0；按周：则为1-7；按月：则为：1-31；按间隔时间：则为间隔时间，单位：秒；默认0
	 * @return excuteDateList
	 */
	public List<Integer> getExcuteDateList(){
		return this.excuteDateList;
	}

	/**
	 * 设置 执行日期，按日：则为0；按周：则为1-7；按月：则为：1-31；按间隔时间：则为间隔时间，单位：秒；默认0
	 * @param excuteDateList
	 */
	public void setExcuteDateList(List<Integer> excuteDateList){
		this.excuteDateList = excuteDateList;
	}

	/**
	 * 获取 执行时间，格式：HH:mm，默认：00:00
	 * @return excuteTimeList
	 */
	public List<String> getExcuteTimeList(){
		return this.excuteTimeList;
	}

	/**
	 * 设置 执行时间，格式：HH:mm，默认：00:00
	 * @param excuteTimeList
	 */
	public void setExcuteTimeList(List<String> excuteTimeList){
		this.excuteTimeList = excuteTimeList;
	}

	/**
	 * 获取 备注
	 * @return remarkList
	 */
	public List<String> getRemarkList(){
		return this.remarkList;
	}

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

	/**
	 * 获取 最后执行主机
	 * @return lastExcuteHostList
	 */
	public List<String> getLastExcuteHostList(){
		return this.lastExcuteHostList;
	}

	/**
	 * 设置 最后执行主机
	 * @param lastExcuteHostList
	 */
	public void setLastExcuteHostList(List<String> lastExcuteHostList){
		this.lastExcuteHostList = lastExcuteHostList;
	}

	/**
	 * 获取 开始 最后执行时间
	 * @return lastExcuteTimeStart
	 */
	public String getLastExcuteTimeStart(){
		return this.lastExcuteTimeStart;
	}

	/**
	 * 设置 开始 最后执行时间
	 * @param lastExcuteTimeStart
	 */
	public void setLastExcuteTimeStart(String lastExcuteTimeStart){
		this.lastExcuteTimeStart = lastExcuteTimeStart;
	}

	/**
	 * 获取 结束 最后执行时间
	 * @return lastExcuteTimeEnd
	 */
	public String getLastExcuteTimeEnd(){
		return this.lastExcuteTimeEnd;
	}

	/**
	 * 设置 结束 最后执行时间
	 * @param lastExcuteTimeEnd
	 */
	public void setLastExcuteTimeEnd(String lastExcuteTimeEnd){
		this.lastExcuteTimeEnd = lastExcuteTimeEnd;
	}

	/**
	 * 获取 开始 临时执行状态，0：未启用，1：立即执行并保留，2：立即执行并删除，默认0
	 * @return interimExcuteStatusStart
	 */
	public Integer getInterimExcuteStatusStart(){
		return this.interimExcuteStatusStart;
	}

	/**
	 * 设置 开始 临时执行状态，0：未启用，1：立即执行并保留，2：立即执行并删除，默认0
	 * @param interimExcuteStatusStart
	 */
	public void setInterimExcuteStatusStart(Integer interimExcuteStatusStart){
		this.interimExcuteStatusStart = interimExcuteStatusStart;
	}

	/**
	 * 获取 结束 临时执行状态，0：未启用，1：立即执行并保留，2：立即执行并删除，默认0
	 * @return interimExcuteStatusEnd
	 */
	public Integer getInterimExcuteStatusEnd(){
		return this.interimExcuteStatusEnd;
	}

	/**
	 * 设置 结束 临时执行状态，0：未启用，1：立即执行并保留，2：立即执行并删除，默认0
	 * @param interimExcuteStatusEnd
	 */
	public void setInterimExcuteStatusEnd(Integer interimExcuteStatusEnd){
		this.interimExcuteStatusEnd = interimExcuteStatusEnd;
	}

	/**
	 * 获取 增加 临时执行状态，0：未启用，1：立即执行并保留，2：立即执行并删除，默认0
	 * @return interimExcuteStatusIncrement
	 */
	public Integer getInterimExcuteStatusIncrement(){
		return this.interimExcuteStatusIncrement;
	}

	/**
	 * 设置 增加 临时执行状态，0：未启用，1：立即执行并保留，2：立即执行并删除，默认0
	 * @param interimExcuteStatusIncrement
	 */
	public void setInterimExcuteStatusIncrement(Integer interimExcuteStatusIncrement){
		this.interimExcuteStatusIncrement = interimExcuteStatusIncrement;
	}

	/**
	 * 获取 临时执行状态，0：未启用，1：立即执行并保留，2：立即执行并删除，默认0
	 * @return interimExcuteStatusList
	 */
	public List<Integer> getInterimExcuteStatusList(){
		return this.interimExcuteStatusList;
	}

	/**
	 * 设置 临时执行状态，0：未启用，1：立即执行并保留，2：立即执行并删除，默认0
	 * @param interimExcuteStatusList
	 */
	public void setInterimExcuteStatusList(List<Integer> interimExcuteStatusList){
		this.interimExcuteStatusList = interimExcuteStatusList;
	}

	/**
	 * 获取 开始 创建时间
	 * @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 createUserNameList
	 */
	public List<String> getCreateUserNameList(){
		return this.createUserNameList;
	}

	/**
	 * 设置 创建用户名称
	 * @param createUserNameList
	 */
	public void setCreateUserNameList(List<String> createUserNameList){
		this.createUserNameList = createUserNameList;
	}


}