package cn.ksource.beans;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.apache.commons.lang.StringUtils;


import cn.ksource.core.dao.BaseBean;
import cn.ksource.core.util.ConvertUtil;
import cn.ksource.core.util.StringUtil;

/**
 * 工作流程-节点模版
 */
public class WORKFLOW_TEMPLATE_NODE extends BaseBean{

	public final static Map<String, String> KEYS = new HashMap<String, String>();
	private Map BEAN_VALUES = null;
	
	static {
		KEYS.put("id", "String");
		KEYS.put("nodename", "String");
		KEYS.put("nodetype", "Integer");
		KEYS.put("flowtype", "Integer");
		KEYS.put("paralleltype", "Integer");
		KEYS.put("parallelscale", "Integer");
		KEYS.put("usingstate", "Integer");
		KEYS.put("ordernumber", "Integer");
		KEYS.put("node_start_interface", "String");
		KEYS.put("node_start_interface_note", "String");
		KEYS.put("node_end_interface", "String");
		KEYS.put("node_end_interface_note", "String");
		KEYS.put("dealformurl", "String");
		KEYS.put("queryformurl", "String");
		KEYS.put("mainflowtempid", "String");
		KEYS.put("subflowtempid", "String");
		KEYS.put("allowfallback", "Integer");
		KEYS.put("node_finish_interface", "String");
		KEYS.put("node_finish_interface_note", "String");
		KEYS.put("node_answer_interface", "String");
		KEYS.put("node_answer_interface_note", "String");
	}
	public Map getColumnMap(){
		return KEYS;
	}

	private String id;
	private Boolean isSetted_id = false;;
	
	private String nodename;
	private Boolean isSetted_nodename = false;
	private Integer nodetype;
	private Boolean isSetted_nodetype = false;
	private Integer flowtype;
	private Boolean isSetted_flowtype = false;
	private Integer paralleltype;
	private Boolean isSetted_paralleltype = false;
	private Integer parallelscale;
	private Boolean isSetted_parallelscale = false;
	private Integer usingstate;
	private Boolean isSetted_usingstate = false;
	private Integer ordernumber;
	private Boolean isSetted_ordernumber = false;
	private String node_start_interface;
	private Boolean isSetted_node_start_interface = false;
	private String node_start_interface_note;
	private Boolean isSetted_node_start_interface_note = false;
	private String node_end_interface;
	private Boolean isSetted_node_end_interface = false;
	private String node_end_interface_note;
	private Boolean isSetted_node_end_interface_note = false;
	private String dealformurl;
	private Boolean isSetted_dealformurl = false;
	private String queryformurl;
	private Boolean isSetted_queryformurl = false;
	private String mainflowtempid;
	private Boolean isSetted_mainflowtempid = false;
	private String subflowtempid;
	private Boolean isSetted_subflowtempid = false;
	private Integer allowfallback;
	private Boolean isSetted_allowfallback = false;
	private String node_finish_interface;
	private Boolean isSetted_node_finish_interface = false;
	private String node_finish_interface_note;
	private Boolean isSetted_node_finish_interface_note = false;
	private String node_answer_interface;
	private Boolean isSetted_node_answer_interface = false;
	private String node_answer_interface_note;
	private Boolean isSetted_node_answer_interface_note = false;

	private void initBeanValues(){
		BEAN_VALUES = new HashMap<String, Object>();
		BEAN_VALUES.put("id",id);
			BEAN_VALUES.put("nodename", null);
			BEAN_VALUES.put("nodetype", null);
			BEAN_VALUES.put("flowtype", null);
			BEAN_VALUES.put("paralleltype", null);
			BEAN_VALUES.put("parallelscale", null);
			BEAN_VALUES.put("usingstate", null);
			BEAN_VALUES.put("ordernumber", null);
			BEAN_VALUES.put("node_start_interface", null);
			BEAN_VALUES.put("node_start_interface_note", null);
			BEAN_VALUES.put("node_end_interface", null);
			BEAN_VALUES.put("node_end_interface_note", null);
			BEAN_VALUES.put("dealformurl", null);
			BEAN_VALUES.put("queryformurl", null);
			BEAN_VALUES.put("mainflowtempid", null);
			BEAN_VALUES.put("subflowtempid", null);
			BEAN_VALUES.put("allowfallback", null);
			BEAN_VALUES.put("node_finish_interface", null);
			BEAN_VALUES.put("node_finish_interface_note", null);
			BEAN_VALUES.put("node_answer_interface", null);
			BEAN_VALUES.put("node_answer_interface_note", null);
	}
	
	public WORKFLOW_TEMPLATE_NODE() {
		initBeanValues();
	}
	
	public WORKFLOW_TEMPLATE_NODE(String id) {
		super();
		this.id = id;
		initBeanValues();
		BEAN_VALUES.put("id",id);
	}

    /**
     * 获取ID
     */
	public String getId() {
		return this.id;
	}
	/**
     * 设置ID
     */
	public WORKFLOW_TEMPLATE_NODE setId(String id) {
		this.id = id;
		this.isSetted_id = true;
		BEAN_VALUES.put("id",id);
		return this;
	}
	
	@Override
	public String getUpdateSql() {
		StringBuffer sBuffer = new StringBuffer("update WORKFLOW_TEMPLATE_NODE set ");
			if (isSetted_nodename) {
				sBuffer.append("nodename=:nodename,");
			}
			if (isSetted_nodetype) {
				sBuffer.append("nodetype=:nodetype,");
			}
			if (isSetted_flowtype) {
				sBuffer.append("flowtype=:flowtype,");
			}
			if (isSetted_paralleltype) {
				sBuffer.append("paralleltype=:paralleltype,");
			}
			if (isSetted_parallelscale) {
				sBuffer.append("parallelscale=:parallelscale,");
			}
			if (isSetted_usingstate) {
				sBuffer.append("usingstate=:usingstate,");
			}
			if (isSetted_ordernumber) {
				sBuffer.append("ordernumber=:ordernumber,");
			}
			if (isSetted_node_start_interface) {
				sBuffer.append("node_start_interface=:node_start_interface,");
			}
			if (isSetted_node_start_interface_note) {
				sBuffer.append("node_start_interface_note=:node_start_interface_note,");
			}
			if (isSetted_node_end_interface) {
				sBuffer.append("node_end_interface=:node_end_interface,");
			}
			if (isSetted_node_end_interface_note) {
				sBuffer.append("node_end_interface_note=:node_end_interface_note,");
			}
			if (isSetted_dealformurl) {
				sBuffer.append("dealformurl=:dealformurl,");
			}
			if (isSetted_queryformurl) {
				sBuffer.append("queryformurl=:queryformurl,");
			}
			if (isSetted_mainflowtempid) {
				sBuffer.append("mainflowtempid=:mainflowtempid,");
			}
			if (isSetted_subflowtempid) {
				sBuffer.append("subflowtempid=:subflowtempid,");
			}
			if (isSetted_allowfallback) {
				sBuffer.append("allowfallback=:allowfallback,");
			}
			if (isSetted_node_finish_interface) {
				sBuffer.append("node_finish_interface=:node_finish_interface,");
			}
			if (isSetted_node_finish_interface_note) {
				sBuffer.append("node_finish_interface_note=:node_finish_interface_note,");
			}
			if (isSetted_node_answer_interface) {
				sBuffer.append("node_answer_interface=:node_answer_interface,");
			}
			if (isSetted_node_answer_interface_note) {
				sBuffer.append("node_answer_interface_note=:node_answer_interface_note,");
			}
		String sql = sBuffer.toString();
		return StringUtils.removeEnd(sql, ",") + " where id=:id";
	}
	
	
	@Override
	public String getInsertSql() {
		StringBuffer sBuffer = new StringBuffer("insert into WORKFLOW_TEMPLATE_NODE(");
		StringBuffer fileds = new StringBuffer("id,");
		StringBuffer values = new StringBuffer(":id,");		
			fileds.append("nodename,");
			values.append(":nodename,");
			fileds.append("nodetype,");
			values.append(":nodetype,");
			fileds.append("flowtype,");
			values.append(":flowtype,");
			fileds.append("paralleltype,");
			values.append(":paralleltype,");
			fileds.append("parallelscale,");
			values.append(":parallelscale,");
			fileds.append("usingstate,");
			values.append(":usingstate,");
			fileds.append("ordernumber,");
			values.append(":ordernumber,");
			fileds.append("node_start_interface,");
			values.append(":node_start_interface,");
			fileds.append("node_start_interface_note,");
			values.append(":node_start_interface_note,");
			fileds.append("node_end_interface,");
			values.append(":node_end_interface,");
			fileds.append("node_end_interface_note,");
			values.append(":node_end_interface_note,");
			fileds.append("dealformurl,");
			values.append(":dealformurl,");
			fileds.append("queryformurl,");
			values.append(":queryformurl,");
			fileds.append("mainflowtempid,");
			values.append(":mainflowtempid,");
			fileds.append("subflowtempid,");
			values.append(":subflowtempid,");
			fileds.append("allowfallback,");
			values.append(":allowfallback,");
			fileds.append("node_finish_interface,");
			values.append(":node_finish_interface,");
			fileds.append("node_finish_interface_note,");
			values.append(":node_finish_interface_note,");
			fileds.append("node_answer_interface,");
			values.append(":node_answer_interface,");
			fileds.append("node_answer_interface_note,");
			values.append(":node_answer_interface_note,");
		sBuffer.append(StringUtils.removeEnd(fileds.toString(), ",") + ") values("+StringUtils.removeEnd(values.toString(), ",")+")");
		return sBuffer.toString();
	}
	

		/**
		 * 获取环节名称<BR/>
		 * 䣺2016-15-04 hh:07
		 */
		public String getNodename() {
			return nodename;
		}
		/**
		 * 设置环节名称<BR/>
		 * 2016-15-04 hh:07
		 */
		public WORKFLOW_TEMPLATE_NODE setNodename(String nodename) {
			this.nodename = nodename;
			this.isSetted_nodename = true;
			BEAN_VALUES.put("nodename",nodename);
			return this;
		}
		/**
		 * 获取节点类型（1=开始节点；2=结束节点；3=中间业务节点；4=中间阅知节点；5=子流程节点）<BR/>
		 * 䣺2016-15-04 hh:07
		 */
		public Integer getNodetype() {
			return nodetype;
		}
		/**
		 * 设置节点类型（1=开始节点；2=结束节点；3=中间业务节点；4=中间阅知节点；5=子流程节点）<BR/>
		 * 2016-15-04 hh:07
		 */
		public WORKFLOW_TEMPLATE_NODE setNodetype(Integer nodetype) {
			this.nodetype = nodetype;
			this.isSetted_nodetype = true;
			BEAN_VALUES.put("nodetype",nodetype);
			return this;
		}
		/**
		 * 获取流转类型（1=串行；2=并行；）<BR/>
		 * 䣺2016-15-04 hh:07
		 */
		public Integer getFlowtype() {
			return flowtype;
		}
		/**
		 * 设置流转类型（1=串行；2=并行；）<BR/>
		 * 2016-15-04 hh:07
		 */
		public WORKFLOW_TEMPLATE_NODE setFlowtype(Integer flowtype) {
			this.flowtype = flowtype;
			this.isSetted_flowtype = true;
			BEAN_VALUES.put("flowtype",flowtype);
			return this;
		}
		/**
		 * 获取并行类型（1=1人同意即可；2=全部同意；3=比例同意）<BR/>
		 * 䣺2016-15-04 hh:07
		 */
		public Integer getParalleltype() {
			return paralleltype;
		}
		/**
		 * 设置并行类型（1=1人同意即可；2=全部同意；3=比例同意）<BR/>
		 * 2016-15-04 hh:07
		 */
		public WORKFLOW_TEMPLATE_NODE setParalleltype(Integer paralleltype) {
			this.paralleltype = paralleltype;
			this.isSetted_paralleltype = true;
			BEAN_VALUES.put("paralleltype",paralleltype);
			return this;
		}
		/**
		 * 获取并行同意比例（单位%）<BR/>
		 * 䣺2016-15-04 hh:07
		 */
		public Integer getParallelscale() {
			return parallelscale;
		}
		/**
		 * 设置并行同意比例（单位%）<BR/>
		 * 2016-15-04 hh:07
		 */
		public WORKFLOW_TEMPLATE_NODE setParallelscale(Integer parallelscale) {
			this.parallelscale = parallelscale;
			this.isSetted_parallelscale = true;
			BEAN_VALUES.put("parallelscale",parallelscale);
			return this;
		}
		/**
		 * 获取使用状态（1=正常；2=禁用）<BR/>
		 * 䣺2016-15-04 hh:07
		 */
		public Integer getUsingstate() {
			return usingstate;
		}
		/**
		 * 设置使用状态（1=正常；2=禁用）<BR/>
		 * 2016-15-04 hh:07
		 */
		public WORKFLOW_TEMPLATE_NODE setUsingstate(Integer usingstate) {
			this.usingstate = usingstate;
			this.isSetted_usingstate = true;
			BEAN_VALUES.put("usingstate",usingstate);
			return this;
		}
		/**
		 * 获取节点顺序<BR/>
		 * 䣺2016-15-04 hh:07
		 */
		public Integer getOrdernumber() {
			return ordernumber;
		}
		/**
		 * 设置节点顺序<BR/>
		 * 2016-15-04 hh:07
		 */
		public WORKFLOW_TEMPLATE_NODE setOrdernumber(Integer ordernumber) {
			this.ordernumber = ordernumber;
			this.isSetted_ordernumber = true;
			BEAN_VALUES.put("ordernumber",ordernumber);
			return this;
		}
		/**
		 * 获取节点进入时接口<BR/>
		 * 䣺2016-15-04 hh:07
		 */
		public String getNode_start_interface() {
			return node_start_interface;
		}
		/**
		 * 设置节点进入时接口<BR/>
		 * 2016-15-04 hh:07
		 */
		public WORKFLOW_TEMPLATE_NODE setNode_start_interface(String node_start_interface) {
			this.node_start_interface = node_start_interface;
			this.isSetted_node_start_interface = true;
			BEAN_VALUES.put("node_start_interface",node_start_interface);
			return this;
		}
		/**
		 * 获取节点进入时接口说明<BR/>
		 * 䣺2016-15-04 hh:07
		 */
		public String getNode_start_interface_note() {
			return node_start_interface_note;
		}
		/**
		 * 设置节点进入时接口说明<BR/>
		 * 2016-15-04 hh:07
		 */
		public WORKFLOW_TEMPLATE_NODE setNode_start_interface_note(String node_start_interface_note) {
			this.node_start_interface_note = node_start_interface_note;
			this.isSetted_node_start_interface_note = true;
			BEAN_VALUES.put("node_start_interface_note",node_start_interface_note);
			return this;
		}
		/**
		 * 获取节点结束时接口<BR/>
		 * 䣺2016-15-04 hh:07
		 */
		public String getNode_end_interface() {
			return node_end_interface;
		}
		/**
		 * 设置节点结束时接口<BR/>
		 * 2016-15-04 hh:07
		 */
		public WORKFLOW_TEMPLATE_NODE setNode_end_interface(String node_end_interface) {
			this.node_end_interface = node_end_interface;
			this.isSetted_node_end_interface = true;
			BEAN_VALUES.put("node_end_interface",node_end_interface);
			return this;
		}
		/**
		 * 获取节点结束时接口说明<BR/>
		 * 䣺2016-15-04 hh:07
		 */
		public String getNode_end_interface_note() {
			return node_end_interface_note;
		}
		/**
		 * 设置节点结束时接口说明<BR/>
		 * 2016-15-04 hh:07
		 */
		public WORKFLOW_TEMPLATE_NODE setNode_end_interface_note(String node_end_interface_note) {
			this.node_end_interface_note = node_end_interface_note;
			this.isSetted_node_end_interface_note = true;
			BEAN_VALUES.put("node_end_interface_note",node_end_interface_note);
			return this;
		}
		/**
		 * 获取处理表单地址<BR/>
		 * 䣺2016-15-04 hh:07
		 */
		public String getDealformurl() {
			return dealformurl;
		}
		/**
		 * 设置处理表单地址<BR/>
		 * 2016-15-04 hh:07
		 */
		public WORKFLOW_TEMPLATE_NODE setDealformurl(String dealformurl) {
			this.dealformurl = dealformurl;
			this.isSetted_dealformurl = true;
			BEAN_VALUES.put("dealformurl",dealformurl);
			return this;
		}
		/**
		 * 获取查询表单地址<BR/>
		 * 䣺2016-15-04 hh:07
		 */
		public String getQueryformurl() {
			return queryformurl;
		}
		/**
		 * 设置查询表单地址<BR/>
		 * 2016-15-04 hh:07
		 */
		public WORKFLOW_TEMPLATE_NODE setQueryformurl(String queryformurl) {
			this.queryformurl = queryformurl;
			this.isSetted_queryformurl = true;
			BEAN_VALUES.put("queryformurl",queryformurl);
			return this;
		}
		/**
		 * 获取主流程模版编号<BR/>
		 * 䣺2016-15-04 hh:07
		 */
		public String getMainflowtempid() {
			return mainflowtempid;
		}
		/**
		 * 设置主流程模版编号<BR/>
		 * 2016-15-04 hh:07
		 */
		public WORKFLOW_TEMPLATE_NODE setMainflowtempid(String mainflowtempid) {
			this.mainflowtempid = mainflowtempid;
			this.isSetted_mainflowtempid = true;
			BEAN_VALUES.put("mainflowtempid",mainflowtempid);
			return this;
		}
		/**
		 * 获取子流程模版编号<BR/>
		 * 䣺2016-15-04 hh:07
		 */
		public String getSubflowtempid() {
			return subflowtempid;
		}
		/**
		 * 设置子流程模版编号<BR/>
		 * 2016-15-04 hh:07
		 */
		public WORKFLOW_TEMPLATE_NODE setSubflowtempid(String subflowtempid) {
			this.subflowtempid = subflowtempid;
			this.isSetted_subflowtempid = true;
			BEAN_VALUES.put("subflowtempid",subflowtempid);
			return this;
		}
		/**
		 * 获取可否回退（1=是；2=否）<BR/>
		 * 䣺2016-15-04 hh:07
		 */
		public Integer getAllowfallback() {
			return allowfallback;
		}
		/**
		 * 设置可否回退（1=是；2=否）<BR/>
		 * 2016-15-04 hh:07
		 */
		public WORKFLOW_TEMPLATE_NODE setAllowfallback(Integer allowfallback) {
			this.allowfallback = allowfallback;
			this.isSetted_allowfallback = true;
			BEAN_VALUES.put("allowfallback",allowfallback);
			return this;
		}
		/**
		 * 获取节点完成时接口<BR/>
		 * 䣺2016-15-04 hh:07
		 */
		public String getNode_finish_interface() {
			return node_finish_interface;
		}
		/**
		 * 设置节点完成时接口<BR/>
		 * 2016-15-04 hh:07
		 */
		public WORKFLOW_TEMPLATE_NODE setNode_finish_interface(String node_finish_interface) {
			this.node_finish_interface = node_finish_interface;
			this.isSetted_node_finish_interface = true;
			BEAN_VALUES.put("node_finish_interface",node_finish_interface);
			return this;
		}
		/**
		 * 获取节点完成时接口说明<BR/>
		 * 䣺2016-15-04 hh:07
		 */
		public String getNode_finish_interface_note() {
			return node_finish_interface_note;
		}
		/**
		 * 设置节点完成时接口说明<BR/>
		 * 2016-15-04 hh:07
		 */
		public WORKFLOW_TEMPLATE_NODE setNode_finish_interface_note(String node_finish_interface_note) {
			this.node_finish_interface_note = node_finish_interface_note;
			this.isSetted_node_finish_interface_note = true;
			BEAN_VALUES.put("node_finish_interface_note",node_finish_interface_note);
			return this;
		}
		/**
		 * 获取节点响应时接口<BR/>
		 * 䣺2016-15-04 hh:07
		 */
		public String getNode_answer_interface() {
			return node_answer_interface;
		}
		/**
		 * 设置节点响应时接口<BR/>
		 * 2016-15-04 hh:07
		 */
		public WORKFLOW_TEMPLATE_NODE setNode_answer_interface(String node_answer_interface) {
			this.node_answer_interface = node_answer_interface;
			this.isSetted_node_answer_interface = true;
			BEAN_VALUES.put("node_answer_interface",node_answer_interface);
			return this;
		}
		/**
		 * 获取节点响应时接口说明<BR/>
		 * 䣺2016-15-04 hh:07
		 */
		public String getNode_answer_interface_note() {
			return node_answer_interface_note;
		}
		/**
		 * 设置节点响应时接口说明<BR/>
		 * 2016-15-04 hh:07
		 */
		public WORKFLOW_TEMPLATE_NODE setNode_answer_interface_note(String node_answer_interface_note) {
			this.node_answer_interface_note = node_answer_interface_note;
			this.isSetted_node_answer_interface_note = true;
			BEAN_VALUES.put("node_answer_interface_note",node_answer_interface_note);
			return this;
		}

		/**
		 * 使用ID删除Bean<BR/>
		 */
		public void deleteById() {
			if (StringUtils.isBlank(id)) {
				throw new RuntimeException("删除bean时ID不能为空");
			}
			dao.execute("delete from " + getTableName() + " where id = :id", BEAN_VALUES);
		}
	
		@Override
		public WORKFLOW_TEMPLATE_NODE getInstanceById() {
			if (StringUtils.isBlank(id)) {
				throw new RuntimeException("获取Bean时ID不能为空");
			}
			return dao.queryForBean("select * from " + getTableName() + " where id=:id", BEAN_VALUES, this);
		}
	
		
		
		@Override
		public WORKFLOW_TEMPLATE_NODE queryForBean() {
			StringBuffer sBuffer = new StringBuffer("select * from WORKFLOW_TEMPLATE_NODE where ");
			if(isSetted_id){
				sBuffer.append("id=:id and ");
			}
				if (isSetted_nodename) {
					sBuffer.append("nodename=:nodename and ");
				}
				if (isSetted_nodetype) {
					sBuffer.append("nodetype=:nodetype and ");
				}
				if (isSetted_flowtype) {
					sBuffer.append("flowtype=:flowtype and ");
				}
				if (isSetted_paralleltype) {
					sBuffer.append("paralleltype=:paralleltype and ");
				}
				if (isSetted_parallelscale) {
					sBuffer.append("parallelscale=:parallelscale and ");
				}
				if (isSetted_usingstate) {
					sBuffer.append("usingstate=:usingstate and ");
				}
				if (isSetted_ordernumber) {
					sBuffer.append("ordernumber=:ordernumber and ");
				}
				if (isSetted_node_start_interface) {
					sBuffer.append("node_start_interface=:node_start_interface and ");
				}
				if (isSetted_node_start_interface_note) {
					sBuffer.append("node_start_interface_note=:node_start_interface_note and ");
				}
				if (isSetted_node_end_interface) {
					sBuffer.append("node_end_interface=:node_end_interface and ");
				}
				if (isSetted_node_end_interface_note) {
					sBuffer.append("node_end_interface_note=:node_end_interface_note and ");
				}
				if (isSetted_dealformurl) {
					sBuffer.append("dealformurl=:dealformurl and ");
				}
				if (isSetted_queryformurl) {
					sBuffer.append("queryformurl=:queryformurl and ");
				}
				if (isSetted_mainflowtempid) {
					sBuffer.append("mainflowtempid=:mainflowtempid and ");
				}
				if (isSetted_subflowtempid) {
					sBuffer.append("subflowtempid=:subflowtempid and ");
				}
				if (isSetted_allowfallback) {
					sBuffer.append("allowfallback=:allowfallback and ");
				}
				if (isSetted_node_finish_interface) {
					sBuffer.append("node_finish_interface=:node_finish_interface and ");
				}
				if (isSetted_node_finish_interface_note) {
					sBuffer.append("node_finish_interface_note=:node_finish_interface_note and ");
				}
				if (isSetted_node_answer_interface) {
					sBuffer.append("node_answer_interface=:node_answer_interface and ");
				}
				if (isSetted_node_answer_interface_note) {
					sBuffer.append("node_answer_interface_note=:node_answer_interface_note and ");
				}
			String sql = sBuffer.toString();
			sql = StringUtils.removeEnd(sql, " and ");
			return dao.queryForBean(sql,this);
		}
	
		@Override
		public String getTableName() {
			return "WORKFLOW_TEMPLATE_NODE";
		}
		
		
		public Map getBeanValues(){
			return this.BEAN_VALUES;
		}
	
		@Override
		public WORKFLOW_TEMPLATE_NODE insert() {
			if (StringUtils.isBlank(id)) {
				this.setId(StringUtil.getUUID());
			}
			dao.execute(getInsertSql(),BEAN_VALUES);
			return this;
		}
	
		@Override
		public WORKFLOW_TEMPLATE_NODE update() {
			if (StringUtils.isBlank(id)) {
				throw new RuntimeException("更新Bean时ID不能为空");
			}
			dao.execute(getUpdateSql(),BEAN_VALUES);
			return this;
		}  
		
		public WORKFLOW_TEMPLATE_NODE insertOrUpdate(){
			if (StringUtils.isNotBlank(id)) {
				return update();
			} else {
				return insert();
			}
		}
		
		/**
		 * 通过ID获取该条信息的Map结构
		 */
		public Map getBeanMapById() {
			
			if (StringUtils.isBlank(id)) {
				throw new RuntimeException("ID不能为空!");
			}
			
			return dao.queryForMap("select * from WORKFLOW_TEMPLATE_NODE where id=:id",BEAN_VALUES);
		}

		public Object mapRow(ResultSet rs, int rownum) throws SQLException {
			Object id = rs.getObject("ID");
			this.setId(ConvertUtil.obj2Str(id));
			BEAN_VALUES.put("id",id);
			Object obj = null;
			obj = rs.getObject("NODENAME");
			BEAN_VALUES.put("nodename",obj);
				this.setNodename(ConvertUtil.obj2Str(obj));
			obj = rs.getObject("NODETYPE");
			BEAN_VALUES.put("nodetype",obj);
				this.setNodetype(ConvertUtil.obj2Integer(obj));
			obj = rs.getObject("FLOWTYPE");
			BEAN_VALUES.put("flowtype",obj);
				this.setFlowtype(ConvertUtil.obj2Integer(obj));
			obj = rs.getObject("PARALLELTYPE");
			BEAN_VALUES.put("paralleltype",obj);
				this.setParalleltype(ConvertUtil.obj2Integer(obj));
			obj = rs.getObject("PARALLELSCALE");
			BEAN_VALUES.put("parallelscale",obj);
				this.setParallelscale(ConvertUtil.obj2Integer(obj));
			obj = rs.getObject("USINGSTATE");
			BEAN_VALUES.put("usingstate",obj);
				this.setUsingstate(ConvertUtil.obj2Integer(obj));
			obj = rs.getObject("ORDERNUMBER");
			BEAN_VALUES.put("ordernumber",obj);
				this.setOrdernumber(ConvertUtil.obj2Integer(obj));
			obj = rs.getObject("NODE_START_INTERFACE");
			BEAN_VALUES.put("node_start_interface",obj);
				this.setNode_start_interface(ConvertUtil.obj2Str(obj));
			obj = rs.getObject("NODE_START_INTERFACE_NOTE");
			BEAN_VALUES.put("node_start_interface_note",obj);
				this.setNode_start_interface_note(ConvertUtil.obj2Str(obj));
			obj = rs.getObject("NODE_END_INTERFACE");
			BEAN_VALUES.put("node_end_interface",obj);
				this.setNode_end_interface(ConvertUtil.obj2Str(obj));
			obj = rs.getObject("NODE_END_INTERFACE_NOTE");
			BEAN_VALUES.put("node_end_interface_note",obj);
				this.setNode_end_interface_note(ConvertUtil.obj2Str(obj));
			obj = rs.getObject("DEALFORMURL");
			BEAN_VALUES.put("dealformurl",obj);
				this.setDealformurl(ConvertUtil.obj2Str(obj));
			obj = rs.getObject("QUERYFORMURL");
			BEAN_VALUES.put("queryformurl",obj);
				this.setQueryformurl(ConvertUtil.obj2Str(obj));
			obj = rs.getObject("MAINFLOWTEMPID");
			BEAN_VALUES.put("mainflowtempid",obj);
				this.setMainflowtempid(ConvertUtil.obj2Str(obj));
			obj = rs.getObject("SUBFLOWTEMPID");
			BEAN_VALUES.put("subflowtempid",obj);
				this.setSubflowtempid(ConvertUtil.obj2Str(obj));
			obj = rs.getObject("ALLOWFALLBACK");
			BEAN_VALUES.put("allowfallback",obj);
				this.setAllowfallback(ConvertUtil.obj2Integer(obj));
			obj = rs.getObject("NODE_FINISH_INTERFACE");
			BEAN_VALUES.put("node_finish_interface",obj);
				this.setNode_finish_interface(ConvertUtil.obj2Str(obj));
			obj = rs.getObject("NODE_FINISH_INTERFACE_NOTE");
			BEAN_VALUES.put("node_finish_interface_note",obj);
				this.setNode_finish_interface_note(ConvertUtil.obj2Str(obj));
			obj = rs.getObject("NODE_ANSWER_INTERFACE");
			BEAN_VALUES.put("node_answer_interface",obj);
				this.setNode_answer_interface(ConvertUtil.obj2Str(obj));
			obj = rs.getObject("NODE_ANSWER_INTERFACE_NOTE");
			BEAN_VALUES.put("node_answer_interface_note",obj);
				this.setNode_answer_interface_note(ConvertUtil.obj2Str(obj));
			return this;
		}
		
		
		public String toString() {
			StringBuffer sb = new StringBuffer("[");
			for (Iterator iterator = KEYS.keySet().iterator(); iterator.hasNext();) {
				String key = (String) iterator.next();
				sb.append(key+"=" + BEAN_VALUES.get(key)+",");
			}
			sb.append("]");
			return sb.toString();
		}
		
		public WORKFLOW_TEMPLATE_NODE newInstance(){
			return new WORKFLOW_TEMPLATE_NODE();
		}



















}