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

package com.mortals.xhx.base.system.task.model;

import com.mortals.framework.model.BaseEntityLong;
import com.mortals.framework.service.ITask;

import java.util.Date;

/**
 * <p>Title: 任务信息</p>
 * <p>Description: TaskEntity  </p>
 * <p>Copyright: Copyright &reg;  </p>
 * <p>Company: </p>
 * @author 
 * @version 1.0.0
 */
public class TaskEntity extends BaseEntityLong implements ITask{
	private static final long serialVersionUID = 1547777703372L;
	
	/** 任务名称 */
	private String name;

	/** 任务关键字，区分任务执行流程 */
	private String taskKey;

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

	/** 任务执行服务 */
	private String excuteService;

	/** 任务执行参数 */
	private String excuteParam;

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

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

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

	/** 执行时间，格式：HH:mm，默认：00:00 */
	private String excuteTime;

	/** 备注 */
	private String remark;

	/** 最后执行主机 */
	private String lastExcuteHost;

	/** 最后执行时间 */
	private Date lastExcuteTime;

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

	/** 创建时间 */
	private Date createTime;

	/** 创建用户 */
	private Long createUserId;

	/** 创建用户名称 */
	private String createUserName;


	public TaskEntity(){
		
	}
	/**
	 * 获取 任务名称
	 * @return name
	 */
	public String getName(){
		return this.name;
	}

	/**
	 * 设置 任务名称
	 * @param name
	 */
	public void setName(String name){
		this.name = name;
	}

	/**
	 * 获取 任务关键字，区分任务执行流程
	 * @return taskKey
	 */
	public String getTaskKey(){
		return this.taskKey;
	}

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

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

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

	/**
	 * 获取 任务执行服务
	 * @return excuteService
	 */
	public String getExcuteService(){
		return this.excuteService;
	}

	/**
	 * 设置 任务执行服务
	 * @param excuteService
	 */
	public void setExcuteService(String excuteService){
		this.excuteService = excuteService;
	}

	/**
	 * 获取 任务执行参数
	 * @return excuteParam
	 */
	public String getExcuteParam(){
		return this.excuteParam;
	}

	/**
	 * 设置 任务执行参数
	 * @param excuteParam
	 */
	public void setExcuteParam(String excuteParam){
		this.excuteParam = excuteParam;
	}

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

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

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

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

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

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

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

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

	/**
	 * 获取 备注
	 * @return remark
	 */
	public String getRemark(){
		return this.remark;
	}

	/**
	 * 设置 备注
	 * @param remark
	 */
	public void setRemark(String remark){
		this.remark = remark;
	}

	/**
	 * 获取 最后执行主机
	 * @return lastExcuteHost
	 */
	public String getLastExcuteHost(){
		return this.lastExcuteHost;
	}

	/**
	 * 设置 最后执行主机
	 * @param lastExcuteHost
	 */
	public void setLastExcuteHost(String lastExcuteHost){
		this.lastExcuteHost = lastExcuteHost;
	}

	/**
	 * 获取 最后执行时间
	 * @return lastExcuteTime
	 */
	public Date getLastExcuteTime(){
		return this.lastExcuteTime;
	}

	/**
	 * 设置 最后执行时间
	 * @param lastExcuteTime
	 */
	public void setLastExcuteTime(Date lastExcuteTime){
		this.lastExcuteTime = lastExcuteTime;
	}

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

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

	/**
	 * 获取 创建时间
	 * @return createTime
	 */
	public Date getCreateTime(){
		return this.createTime;
	}

	/**
	 * 设置 创建时间
	 * @param createTime
	 */
	public void setCreateTime(Date createTime){
		this.createTime = createTime;
	}

	/**
	 * 获取 创建用户
	 * @return createUserId
	 */
	public Long getCreateUserId(){
		return this.createUserId;
	}

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

	/**
	 * 获取 创建用户名称
	 * @return createUserName
	 */
	public String getCreateUserName(){
		return this.createUserName;
	}

	/**
	 * 设置 创建用户名称
	 * @param createUserName
	 */
	public void setCreateUserName(String createUserName){
		this.createUserName = createUserName;
	}


	@Override
	public int hashCode() {
		return this.getId().hashCode();
	}
	@Override
	public boolean equals(Object obj) {
		if (obj == null)
			return false;
		if (obj instanceof TaskEntity) {
			TaskEntity tmp = (TaskEntity) obj;
			if (this.getId().longValue() == tmp.getId().longValue()) {
				return true;
			}
		}
		return false;
	}
	public String toString(){
		StringBuilder sb = new StringBuilder("");
		sb.append("id:").append(getId())
		  .append(",name:").append(getName())
		  .append(",taskKey:").append(getTaskKey())
		  .append(",status:").append(getStatus())
		  .append(",excuteService:").append(getExcuteService())
		  .append(",excuteParam:").append(getExcuteParam())
		  .append(",excuteHost:").append(getExcuteHost())
		  .append(",excuteStrategy:").append(getExcuteStrategy())
		  .append(",excuteDate:").append(getExcuteDate())
		  .append(",excuteTime:").append(getExcuteTime())
		  .append(",remark:").append(getRemark())
		  .append(",lastExcuteHost:").append(getLastExcuteHost())
		  .append(",lastExcuteTime:").append(getLastExcuteTime())
		  .append(",interimExcuteStatus:").append(getInterimExcuteStatus())
		  .append(",createTime:").append(getCreateTime())
		  .append(",createUserId:").append(getCreateUserId())
		  .append(",createUserName:").append(getCreateUserName());
		return sb.toString();
	}
	public void initAttrValue(){
		this.name = null;
		this.taskKey = null;
		this.status = 0;
		this.excuteService = null;
		this.excuteParam = null;
		this.excuteHost = null;
		this.excuteStrategy = 1;
		this.excuteDate = 0;
		this.excuteTime = "00";
		this.remark = null;
		this.lastExcuteHost = null;
		this.lastExcuteTime = null;
		this.interimExcuteStatus = 0;
		this.createTime = null;
		this.createUserId = null;
		this.createUserName = null;
	}
}