HR代码

于 2012-07-25 07:43:27 发布
阅读量1k 收藏
点赞数
文章标签： list object delete session class sql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qswboy/article/details/7782934
版权

包名：

package org.better.hr.dao;

、、、、、、、、、、、、、、、、、、、、、、、、、、、

package org.better.hr.dao;

import java.util.List;

import org.better.hr.comm.page.PageResult;
import org.better.hr.entity.ConfigPrimaryKey;
import org.hibernate.Query;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

public class BasicDao extends HibernateDaoSupport {
 /**
  * 根据ID号返回该对象
  * @param id 主键id号
  * @return Object 对象
  */
 public Object load(Class clazz,java.io.Serializable id)
 {
  return this.getHibernateTemplate().get(clazz, id);
 }
 
 /**
  * 保存方法
  * @param item Object对象
  */
 public void add(Object item) { 
  
  this.getHibernateTemplate().save(item);
 }
 
 /**
  * 更新方法
  * @param item Object对象
  */
 public void update(Object item)
 {
  this.getHibernateTemplate().update(item);
 }
 
 /**
  * 删除方法
  * @param id 主键序列号
  */
 public void delete(Class clazz,java.io.Serializable key)
 {
  this.getHibernateTemplate().delete(this.load(clazz,key));
 }
 
 /**
  * 删除方法，重载
  * @param item Object对象
  */
 public void delete(Object item)
 {
  this.getHibernateTemplate().delete(item);
 }
 
 /**
  * 查
  * @param hql
  * @param pageResult
  */
 public void list(String hql, PageResult pageResult) {   
   if (null==hql)
   {
    return ;
   }
   Query query = this.getSession().createQuery(hql);
   query.setFirstResult(pageResult.getFirstRec());
   query.setMaxResults(pageResult.getPageSize());
   List ret = query.list();
   pageResult.setList(ret);

   String queryString = "";
   if (hql.toUpperCase().indexOf("SELECT") != -1) {
    int i = query.getQueryString().toUpperCase()
      .indexOf("FROM");
    queryString = "Select count(*) "
      + hql.substring(i,hql.length());
   } else {
    queryString = "Select count(*) " + hql;
   }
   Query cquery = this.getSession().createQuery(queryString);
   cquery.setCacheable(true);
   int recTotal = ((Integer)cquery.iterate().next()).intValue();
   
   pageResult.setRecTotal(recTotal);
 }
 
 /**
  * 根据关键字进行查询
  * @param key 关键字
  * @return
  */
 public String listByKey(String ClassName,String key)
 {
  //将所需表的有效关键字查出
  String sql = " from ConfigPrimaryKey where primaryKeyStatus = 1 and primaryKeyTable = '" + ClassName + "'";
  List list = this.getHibernateTemplate().find(sql);
  
  String listSql = "from " + ClassName + " where 1 = 2 ";
  for(int i=0; i<list.size();i++)
  {
   ConfigPrimaryKey keys = (ConfigPrimaryKey)list.get(i);
   listSql += "or " + keys.getPrimaryKey() + " like '%" + key + "%'";
  }
  
  if(listSql.indexOf("or") != -1)
  {
   int i = listSql.indexOf("or");
   listSql = "from " + ClassName + " where 1 = 2 or (" + listSql.substring(i+2, listSql.length()) + ")";
  }
  return listSql;
 }
}

、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、

package org.better.hr.dao;

import java.io.Serializable;
import java.util.List;

import org.better.hr.comm.Util;
import org.better.hr.entity.ConfigFileFirstKind;
import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.criterion.MatchMode;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Restrictions;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

 

public class ConfigFileFirstKindDao extends HibernateDaoSupport {
 
 /**
  * 根据ID号返回该对象
  * @param id 主键id号
  * @return ConfigFileFirstKind 对象
  */
 public ConfigFileFirstKind load(Serializable id)
 { 
  
  return (ConfigFileFirstKind)(this.getHibernateTemplate().get(ConfigFileFirstKind.class, id));
 }
 
 /**
  * 查询方法,根据hbm.xml中的<sql-query>中的查询语句进行查询
  * @return 存放ConfigFileFirstKind对象的集合
  */
 public List find(){
  List list = this.getHibernateTemplate().find("select max(c.ffkId) from ConfigFileFirstKind c");
  return list;
 }
 
 /**
  * 查询方法，重载
  * @param condition 对象，该对象中设定了查询条件
  * @return　存放ConfigFileFirstKind对象的集合
  */
 public List find(final ConfigFileFirstKind condition)
 {
  return this.getHibernateTemplate().executeFind(
    new HibernateCallback()
    {
     public Object doInHibernate(Session s) throws HibernateException{
      Criteria c = s.createCriteria(ConfigFileFirstKind.class);
      if (null != condition)
      {
       if (!Util.isNullOrBlank(condition.getFirstKindId())) {
        c.add(Restrictions
          .eq("firstKindId", condition.getFirstKindId()));
       }
       if (!Util.isNullOrBlank(condition.getFirstKindName())) {
        c.add(Restrictions
          .like("firstKindName", condition.getFirstKindName(),MatchMode.ANYWHERE));
       }
       if (!Util.isNullOrBlank(condition.getFirstKindSalaryId())) {
        c.add(Restrictions
          .like("firstKindSalaryId", condition.getFirstKindSalaryId(),MatchMode.ANYWHERE));
       }
       if (!Util.isNullOrBlank(condition.getFirstKindSaleId())) {
        c.add(Restrictions
          .like("firstKindSaleId", condition.getFirstKindSaleId(),MatchMode.ANYWHERE));
       }
      }
      c.addOrder(Order.asc("ffkId"));
      return c.list();
     }
    }
  );
 }

 /**
  * 保存方法
  * @param item ConfigFileFirstKindind对象
  */
 public void add(ConfigFileFirstKind item) { 
  
  this.getHibernateTemplate().save(item);
 }
 
 /**
  * 更新方法
  * @param item ConfigFileFirstKind对象
  */
 public void update(ConfigFileFirstKind item)
 {
  this.getHibernateTemplate().update(item);
 }
 
 /**
  * 删除方法
  * @param id 主键序列号
  */
 public void delete(java.io.Serializable key)
 {
  this.getHibernateTemplate().delete(this.load(key));
 }
 
 /**
  * 删除方法，重载
  * @param item ConfigFileFirstKind对象
  */
 public void delete(ConfigFileFirstKind item)
 {
  this.getHibernateTemplate().delete(item);
 }
}

、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、

package org.better.hr.dao;

import java.util.List;

import org.better.hr.comm.Util;
import org.better.hr.entity.ConfigFileSecondKind;
import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.criterion.MatchMode;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Restrictions;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

 

public class ConfigFileSecondKindDao extends HibernateDaoSupport {
 
 /**
  * 根据ID号返回该对象
  * @param id 主键id号
  * @return ConfigFileSecondKind 对象
  */
 public ConfigFileSecondKind load(java.io.Serializable id)
 {
  return (ConfigFileSecondKind)this.getHibernateTemplate().get(ConfigFileSecondKind.class, id);
 }
 
 /**
  * 查询方法,根据hbm.xml中的<sql-query>中的查询语句进行查询
  * @return 存放ConfigFileSecondKind对象的集合
  */
 public List find(){
  List list = this.getHibernateTemplate().findByNamedQuery("search_sql");
  return list;
 }
 
 /**
  * 查询方法，重载
  * @param condition 对象，该对象中设定了查询条件
  * @return　存放ConfigFileSecondKind对象的集合
  */
 public List find(final ConfigFileSecondKind condition)
 {
  return this.getHibernateTemplate().executeFind(
    new HibernateCallback()
    {
     public Object doInHibernate(Session s) throws HibernateException{
      Criteria c = s.createCriteria(ConfigFileSecondKind.class);
      if (null != condition)
      {
       if (!Util.isNullOrBlank(condition.getFirstKindId())) {
        c.add(Restrictions
          .like("firstKindId", condition.getFirstKindId(),MatchMode.ANYWHERE));
       }
       if (!Util.isNullOrBlank(condition.getFirstKindName())) {
        c.add(Restrictions
          .like("firstKindName", condition.getFirstKindName()));
       }
       if (!Util.isNullOrBlank(condition.getSecondKindId())) {
        c.add(Restrictions
          .like("secondKindId", condition.getSecondKindId()));
       }
       if (!Util.isNullOrBlank(condition.getSecondKindName())) {
        c.add(Restrictions
          .like("secondKindName", condition.getSecondKindName()));
       }
       if (!Util.isNullOrBlank(condition.getSecondSalaryId())) {
        c.add(Restrictions
          .like("secondSalaryId", condition.getSecondSalaryId()));
       }
       if (!Util.isNullOrBlank(condition.getSecondSaleId())) {
        c.add(Restrictions
          .like("secondSaleId", condition.getSecondSaleId()));
       }
      }
      c.addOrder(Order.asc("fskId"));
      return c.list();
     }
    }
  );
 }

 /**
  * 保存方法
  * @param item ConfigFileSecondKind对象
  */
 public void add(ConfigFileSecondKind item) { 
  
  this.getHibernateTemplate().save(item);
 }
 
 /**
  * 更新方法
  * @param item ConfigFileSecondKind对象
  */
 public void update(ConfigFileSecondKind item)
 {
  this.getHibernateTemplate().update(item);
 }
 
 /**
  * 删除方法
  * @param id 主键序列号
  */
 public void delete(java.io.Serializable key)
 {
  this.getHibernateTemplate().delete(this.load(key));
 }
 
 /**
  * 删除方法，重载
  * @param item ConfigFileSecondKind对象
  */
 public void delete(ConfigFileSecondKind item)
 {
  this.getHibernateTemplate().delete(item);
 }
}

、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、

package org.better.hr.dao;

import java.util.List;

import org.better.hr.entity.ConfigFileThirdKind;
import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.criterion.Order;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
import org.springframework.orm.hibernate3.HibernateCallback;

public class ConfigFileThirdKindDao extends HibernateDaoSupport {

 /**
  * 根据ID号返回该对象
  * @param id 主键id号
  * @return ConfigFileThirdKind 对象
  */
 public ConfigFileThirdKind load(java.io.Serializable id)
 {
  return (ConfigFileThirdKind)this.getHibernateTemplate().get(ConfigFileThirdKind.class, id);
 }
 
 /**
  * 查询方法,根据hbm.xml中的<sql-query>中的查询语句进行查询
  * @return 存放ConfigFileThirdKind对象的集合
  */
 public List find(){
  List list = this.getHibernateTemplate().findByNamedQuery("search_sql");
  return list;
 }
 
 /**
  * 查询方法，重载
  * @param condition 对象，该对象中设定了查询条件
  * @return　存放ConfigFileThirdKind对象的集合
  */
 public List find(final ConfigFileThirdKind condition)
 {
  return this.getHibernateTemplate().executeFind(
    new HibernateCallback()
    {
     public Object doInHibernate(Session s) throws HibernateException{
      Criteria c = s.createCriteria(ConfigFileThirdKind.class);
      if (null != condition)
      {
       
      }
      c.addOrder(Order.asc("ftkId"));
      return c.list();
     }
    }
  );
 }

 /**
  * 保存方法
  * @param item ConfigFileThirdKind对象
  */
 public void add(ConfigFileThirdKind item) { 
  
  this.getHibernateTemplate().save(item);
 }
 
 /**
  * 更新方法
  * @param item ConfigFileThirdKind对象
  */
 public void update(ConfigFileThirdKind item)
 {
  this.getHibernateTemplate().update(item);
 }
 
 /**
  * 删除方法
  * @param id 主键序列号
  */
 public void delete(java.io.Serializable key)
 {
  this.getHibernateTemplate().delete(this.load(key));
 }
 
 /**
  * 删除方法，重载
  * @param item ConfigFileThirdKind对象
  */
 public void delete(ConfigFileThirdKind item)
 {
  this.getHibernateTemplate().delete(item);
 }

}

、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、

 

package org.better.hr.dao;

import java.util.List;

import org.better.hr.entity.ConfigMajor;
import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.criterion.Order;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

 

public class ConfigMajorDao extends BasicDao{
 /**
  * 查询方法,根据hbm.xml中的<sql-query>中的查询语句进行查询
  * @return 存放ConfigMajorKind对象的集合
  */
 public List find(){
  List list = this.getHibernateTemplate().findByNamedQuery("search_sql");
  return list;
 }
 
 /**
  * 查询方法，重载
  * @param condition 对象，该对象中设定了查询条件
  * @return　存放ConfigMajorKind对象的集合
  */
 public List find(final ConfigMajor condition)
 {
  return this.getHibernateTemplate().executeFind(
    new HibernateCallback()
    {
     public Object doInHibernate(Session s) throws HibernateException{
      Criteria c = s.createCriteria(ConfigMajor.class);
      if (null != condition)
      {
       
      }
      c.addOrder(Order.asc("makId"));
      return c.list();
     }
    }
  );
 }
}

、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、

package org.better.hr.dao;

import java.util.List;

import org.better.hr.comm.Util;
import org.better.hr.entity.ConfigMajorKind;
import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.criterion.MatchMode;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Restrictions;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

 

public class ConfigMajorKindDao extends HibernateDaoSupport {
 
 /**
  * 根据ID号返回该对象
  * @param id 主键id号
  * @return ConfigMajorKind 对象
  */
 public ConfigMajorKind load(java.io.Serializable id)
 {
  return (ConfigMajorKind)this.getHibernateTemplate().get(ConfigMajorKind.class, id);
 }
 
 /**
  * 查询方法,根据hbm.xml中的<sql-query>中的查询语句进行查询
  * @return 存放ConfigMajorKind对象的集合
  */
 public List find(){
  List list = this.getHibernateTemplate().findByNamedQuery("search_sql");
  return list;
 }
 
 /**
  * 查询方法，重载
  * @param condition 对象，该对象中设定了查询条件
  * @return　存放ConfigMajorKind对象的集合
  */
 public List find(final ConfigMajorKind condition)
 {
  return this.getHibernateTemplate().executeFind(
    new HibernateCallback()
    {
     public Object doInHibernate(Session s) throws HibernateException{
      Criteria c = s.createCriteria(ConfigMajorKind.class);
      if (null != condition)
      {
       if (!Util.isNullOrBlank(condition.getMajorKindId())) {
        c.add(Restrictions
          .like("majorKindId", condition.getMajorKindId(),MatchMode.ANYWHERE));
       }
       if (!Util.isNullOrBlank(condition.getMajorKindName())) {
        c.add(Restrictions
          .like("majorKindName", condition.getMajorKindName(),MatchMode.ANYWHERE));
       }
      }
      c.addOrder(Order.asc("mfkId"));
      return c.list();
     }
    }
  );
 }

 /**
  * 保存方法
  * @param item ConfigMajorKind对象
  */
 public void add(ConfigMajorKind item) { 
  
  this.getHibernateTemplate().save(item);
 }
 
 /**
  * 更新方法
  * @param item ConfigMajorKind对象
  */
 public void update(ConfigMajorKind item)
 {
  this.getHibernateTemplate().update(item);
 }
 
 /**
  * 删除方法
  * @param id 主键序列号
  */
 public void delete(java.io.Serializable key)
 {
  this.getHibernateTemplate().delete(this.load(key));
 }
 
 /**
  * 删除方法，重载
  * @param item ConfigMajorKind对象
  */
 public void delete(ConfigMajorKind item)
 {
  this.getHibernateTemplate().delete(item);
 }
}

、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、

package org.better.hr.dao;

import java.io.Serializable;
import java.util.List;

import org.better.hr.comm.Util;
import org.better.hr.entity.ConfigPrimaryKey;
import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Restrictions;
import org.springframework.orm.hibernate3.HibernateCallback;

public class ConfigPrimaryKeyDao extends BasicDao {

 
 /**
  * 查询方法,根据hbm.xml中的<sql-query>中的查询语句进行查询
  * @return 存放Users对象的集合
  */
 public List find(){
  List list = this.getHibernateTemplate().find("");
  return list;
 }
 
 /**
  * 查询方法，重载
  * @param condition 对象，该对象中设定了查询条件
  * @return　存放Users对象的集合
  */
 public List find(final ConfigPrimaryKey condition)
 {
  return this.getHibernateTemplate().executeFind(
    new HibernateCallback()
    {
     public Object doInHibernate(Session s) throws HibernateException{
      Criteria c = s.createCriteria(ConfigPrimaryKey.class);
      if (null != condition)
      {
       if (!Util.isNullOrBlank(condition.getPrimaryKeyTable())) {
        c.add(Restrictions
          .eq("primaryKeyTable", condition.getPrimaryKeyTable()));
       }
      }
      c.addOrder(Order.asc("prkId"));
      return c.list();
     }
    }
  );
 }
}

、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、

package org.better.hr.dao;

import java.util.List;

import org.better.hr.comm.Util;
import org.better.hr.entity.ConfigPublicChar;
import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.criterion.MatchMode;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Restrictions;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;


public class ConfigPublicCharDao extends BasicDao {
 
 /**
  * 查询方法,根据hbm.xml中的<sql-query>中的查询语句进行查询
  * @return 存放ConfigPublicChar对象的集合
  */
 public List find(String sql,Object[] args){
  List list = this.getHibernateTemplate().find(sql,args);
  return list;
 }
 
 /**
  * 查询方法，重载
  * @param condition 对象，该对象中设定了查询条件
  * @return　存放ConfigMajorKind对象的集合
  */
 public List find(final ConfigPublicChar condition)
 {
  return this.getHibernateTemplate().executeFind(
    new HibernateCallback()
    {
     public Object doInHibernate(Session s) throws HibernateException{
      Criteria c = s.createCriteria(ConfigPublicChar.class);
      if (null != condition)
      {
       if (!Util.isNullOrBlank(condition.getAttributeKind())) {
        c.add(Restrictions
          .eq("attributeKind", condition.getAttributeKind()));
       }
       if(!Util.isNullOrBlank(condition.getAttributeName()))
       {
        c.add(Restrictions
          .eq("attributeName", condition.getAttributeName()));
       }
      }
      c.addOrder(Order.asc("attributeKind"));
      return c.list();
     }
    }
  );
 }
}

、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、

package org.better.hr.dao;

import java.util.List;

import org.better.hr.entity.ConfigQuestionFirstKind;
import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.criterion.Order;
import org.springframework.orm.hibernate3.HibernateCallback;

public class ConfigQuestionFirstKindDao extends BasicDao{
 
 /**
  * 查询方法
  * @param condition
  * @return
  */
 public List find(final ConfigQuestionFirstKind condition)
 {
  return this.getHibernateTemplate().executeFind(
    new HibernateCallback()
    {
     public Object doInHibernate(Session s) throws HibernateException{
      Criteria c = s.createCriteria(ConfigQuestionFirstKind.class);
      if (null != condition)
      {
       
      }
      c.addOrder(Order.asc("qfkId"));
      return c.list();
     }
    }
  );
 }
}

、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、

 

package org.better.hr.dao;

import java.util.List;

import org.better.hr.entity.ConfigQuestionSecondKind;
import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.criterion.Order;
import org.springframework.orm.hibernate3.HibernateCallback;

public class ConfigQuestionSecondKindDao extends BasicDao{
 
 /**
  * 查询方法
  * @param condition
  * @return
  */
 public List find(final ConfigQuestionSecondKind condition)
 {
  return this.getHibernateTemplate().executeFind(
    new HibernateCallback()
    {
     public Object doInHibernate(Session s) throws HibernateException{
      Criteria c = s.createCriteria(ConfigQuestionSecondKind.class);
      if (null != condition)
      {
       
      }
      c.addOrder(Order.asc("qskId"));
      return c.list();
     }
    }
  );
 }
}

、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、

package org.better.hr.dao;

import java.io.Serializable;
import java.util.List;

import org.better.hr.comm.Util;
import org.better.hr.entity.EngageInterview;
import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.criterion.MatchMode;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Restrictions;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

public class EngageInterviewDao extends HibernateDaoSupport {

 /**
  * 根据ID号返回该对象
  * @param id 主键id号
  * @return EngageInterview 对象
  */
 public EngageInterview load(Serializable id)
 { 
  return (EngageInterview)(this.getHibernateTemplate().get(EngageInterview.class, id));
 }
 
 /**
  * 查询方法,根据hbm.xml中的<sql-query>中的查询语句进行查询
  * @return 存放EngageResume对象的集合
  */
 public List find(){
  List list = this.getHibernateTemplate().findByNamedQuery("search_sql");
  return list;
 }
 
 /**
  * 查询方法，重载
  * @param condition 对象，该对象中设定了查询条件
  * @return　存放EngageInterview对象的集合
  */
 public List find(final EngageInterview condition)
 {
  return this.getHibernateTemplate().executeFind(
    new HibernateCallback()
    {
     public Object doInHibernate(Session s) throws HibernateException{
      Criteria c = s.createCriteria(EngageInterview.class);
      if (null != condition)
      {
       if(!Util.isNullOrBlank(condition.getResumeId()))
       {
        c.add(Restrictions.eq("resumeId", condition.getResumeId()));
       }
       if(!Util.isNullOrBlank(condition.getCheckStatus()))
       {
        c.add(Restrictions.eq("checkStatus", condition.getCheckStatus()));
       }
      }
      c.addOrder(Order.asc("einId"));
      return c.list();
     }
    }
  );
 }
 
 /**
  * 保存方法
  * @param item EngageInterview对象
  */
 public void add(EngageInterview item) { 
  
  this.getHibernateTemplate().save(item);
 }
 
 /**
  * 更新方法
  * @param item EngageInterview对象
  */
 public void update(EngageInterview item)
 {
  this.getHibernateTemplate().update(item);
 }
 
 /**
  * 删除方法
  * @param id 主键序列号
  */
 public void delete(java.io.Serializable key)
 {
  this.getHibernateTemplate().delete(this.load(key));
 }
 
 /**
  * 删除方法，重载
  * @param item EngageInterview对象
  */
 public void delete(EngageInterview item)
 {
  this.getHibernateTemplate().delete(item);
 }

}

、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、

package org.better.hr.dao;

import java.io.Serializable;
import java.util.List;
import org.better.hr.entity.EngageMajorRelease;
import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.criterion.Order;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

public class EngageMajorReleaseDao extends HibernateDaoSupport {

 /**
  * 根据ID号返回该对象
  * @param id 主键id号
  * @return EngageMajorRelease 对象
  */
 public EngageMajorRelease load(Serializable id)
 { 
  return (EngageMajorRelease)(this.getHibernateTemplate().get(EngageMajorRelease.class, id));
 }
 
 /**
  * 查询方法,根据hbm.xml中的<sql-query>中的查询语句进行查询
  * @return 存放EngageMajorRelease对象的集合
  */
 public List find(){
  List list = this.getHibernateTemplate().findByNamedQuery("search_sql");
  return list;
 }
 
 /**
  * 查询方法，重载
  * @param condition 对象，该对象中设定了查询条件
  * @return　存放EngageMajorRelease对象的集合
  */
 public List find(final EngageMajorRelease condition)
 {
  return this.getHibernateTemplate().executeFind(
    new HibernateCallback()
    {
     public Object doInHibernate(Session s) throws HibernateException{
      Criteria c = s.createCriteria(EngageMajorRelease.class);
      if (null != condition)
      {
       
      }
      c.addOrder(Order.asc("mreId"));
      return c.list();
     }
    }
  );
 }
 
 /**
  * 保存方法
  * @param item EngageMajorRelease对象
  */
 public void add(EngageMajorRelease item) { 
  
  this.getHibernateTemplate().save(item);
 }
 
 /**
  * 更新方法
  * @param item EngageMajorRelease对象
  */
 public void update(EngageMajorRelease item)
 {
  this.getHibernateTemplate().update(item);
 }
 
 /**
  * 删除方法
  * @param id 主键序列号
  */
 public void delete(java.io.Serializable key)
 {
  this.getHibernateTemplate().delete(this.load(key));
 }
 
 /**
  * 删除方法，重载
  * @param item EngageMajorRelease对象
  */
 public void delete(EngageMajorRelease item)
 {
  this.getHibernateTemplate().delete(item);
 }

}

、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、

package org.better.hr.dao;

import java.io.Serializable;
import java.util.List;

import org.better.hr.comm.Util;
import org.better.hr.entity.EngageResume;
import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Restrictions;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

public class EngageResumeDao extends HibernateDaoSupport {

 /**
  * 根据ID号返回该对象
  * @param id 主键id号
  * @return EngageResume 对象
  */
 public EngageResume load(Serializable id)
 { 
  return (EngageResume)(this.getHibernateTemplate().get(EngageResume.class, id));
 }
 
 /**
  * 查询方法,根据hbm.xml中的<sql-query>中的查询语句进行查询
  * @return 存放EngageResume对象的集合
  */
 public List find(){
  List list = this.getHibernateTemplate().findByNamedQuery("search_sql");
  return list;
 }
 
 /**
  * 查询方法，重载
  * @param condition 对象，该对象中设定了查询条件
  * @return　存放EngageResume对象的集合
  */
 public List find(final EngageResume condition)
 {
  return this.getHibernateTemplate().executeFind(
    new HibernateCallback()
    {
     public Object doInHibernate(Session s) throws HibernateException{
      Criteria c = s.createCriteria(EngageResume.class);
      if (null != condition)
      {
       if(!Util.isNullOrBlank(condition.getHumanMajorKindName()))
       {
        c.add(Restrictions.eq("humanMajorKindName", condition.getHumanMajorKindName()));
       }
       if(!Util.isNullOrBlank(condition.getHumanMajorName()))
       {
        c.add(Restrictions.eq("humanMajorName", condition.getHumanMajorName()));
       }
       if(!Util.isNullOrBlank(condition.getCheckStatus()))
       {
        c.add(Restrictions.eq("checkStatus", condition.getCheckStatus()));
       }
       if(!Util.isNullOrBlank(condition.getInterviewStatus()))
       {
        c.add(Restrictions.eq("interviewStatus", condition.getInterviewStatus()));
       }
       if(!Util.isNullOrBlank(condition.getPassCheckStatus()))
       {
        c.add(Restrictions.eq("passCheckStatus", condition.getPassCheckStatus()));
       }
       if(!Util.isNullOrBlank(condition.getStart_registTime()))
       {
        c.add(Restrictions.ge("registTime", condition.getStart_regTime()));
       }
       if(!Util.isNullOrBlank(condition.getEnd_registTime()))
       {
        c.add(Restrictions.le("registTime", condition.getEnd_regTime()));
       }
      }
      c.addOrder(Order.asc("resId"));
      return c.list();
     }
    }
  );
 }
 
 /**
  * 保存方法
  * @param item EngageResume对象
  */
 public void add(EngageResume item) { 
  
  this.getHibernateTemplate().save(item);
 }
 
 /**
  * 更新方法
  * @param item EngageResume对象
  */
 public void update(EngageResume item)
 {
  this.getHibernateTemplate().update(item);
 }
 
 /**
  * 删除方法
  * @param id 主键序列号
  */
 public void delete(java.io.Serializable key)
 {
  this.getHibernateTemplate().delete(this.load(key));
 }
 
 /**
  * 删除方法，重载
  * @param item EngageResume对象
  */
 public void delete(EngageResume item)
 {
  this.getHibernateTemplate().delete(item);
 }

}

、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、

 

package org.better.hr.dao;

import java.util.List;
import org.better.hr.comm.Util;
import org.better.hr.entity.EngageSubjects;
import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Restrictions;
import org.springframework.orm.hibernate3.HibernateCallback;

public class EngageSubjectsDao extends BasicDao {
 
 /**
  * 查询方法
  * @param condition
  * @return
  */
 public List find(final EngageSubjects condition)
 {
  return this.getHibernateTemplate().executeFind(
    new HibernateCallback()
    {
     public Object doInHibernate(Session s) throws HibernateException{
      Criteria c = s.createCriteria(EngageSubjects.class);
      if (null != condition)
      {
       if(!Util.isNullOrBlank(condition.getFirstKindName()))
       {
        c.add(Restrictions.eq("firstKindName", condition.getFirstKindName()));
       }
       if(!Util.isNullOrBlank(condition.getStart_registTime()))
       {
        c.add(Restrictions.ge("registTime", condition.getStart_regTime()));
       }
       if(!Util.isNullOrBlank(condition.getEnd_registTime()))
       {
        c.add(Restrictions.le("registTime", condition.getEnd_regTime()));
       }
      }
      c.addOrder(Order.asc("subId"));
      return c.list();
     }
    }
  );
 }
 
 /**
  * 删除一组集合
  * @param conditions
  */
 public void delete(List conditions)
 {
  this.getHibernateTemplate().deleteAll(conditions);
 }
}

、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、

package org.better.hr.dao;

import java.util.List;

import org.better.hr.comm.Util;
import org.better.hr.entity.ExportFile;
import org.better.hr.entity.ExportFileList;
import org.better.hr.entity.HumanFile;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

 

public class ExportFileDao extends HibernateDaoSupport {
 
 /**
  * 查询方法,根据查询条件和字段拼接查询语句
  * @return
  */
 public List find(HumanFile condition,ExportFileList list){
  String sql = "select ";   //查询语句
  for(int i=0; i<list.size(); i++)
  {
   ExportFile file = (ExportFile)list.get(i);
   sql += file.getColumnEN() + " , ";
  }
  
  if(sql.endsWith(", "))
   sql = sql.substring(0,sql.length() - 2);
  
  sql += "from HumanFile where 1 = 1";
  if(!Util.isNullOrBlank(condition.getFirstKindName()))
   sql += " and firstKindName = '" + condition.getFirstKindName() + "'";
  if(!Util.isNullOrBlank(condition.getSecondKindName()))
   sql += " and secondKindName = '"+ condition.getSecondKindName() + "'";
  if(!Util.isNullOrBlank(condition.getThirdKindName()))
   sql += " and thirdKindName = '"+ condition.getThirdKindName() + "'";
  if(!Util.isNullOrBlank(condition.getStr_startTime()))
   sql += " and RegistTime >= '"+ condition.getStr_startTime() + "'";
  if(!Util.isNullOrBlank(condition.getStr_endTime()))
   sql += " and RegistTime <= '"+ condition.getStr_endTime() + "'";  
  
  return this.getHibernateTemplate().find(sql);
  
 }
}

、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、

package org.better.hr.dao;

import java.util.List;

import org.better.hr.comm.Util;
import org.better.hr.entity.HumanFile;
import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.criterion.MatchMode;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Restrictions;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

 

public class HumanFileDao extends BasicDao {
 
 
 /**
  * 查询方法,根据hbm.xml中的<sql-query>中的查询语句进行查询
  * @return 存放HumanFile对象的集合
  */
 public List find(){
  List list = this.getHibernateTemplate().find("select max(f.hufId) from HumanFile f");
  return list;
 }
 
 /**
  * 查询方法，重载
  * @param condition 对象，该对象中设定了查询条件
  * @return　存放HumanFile对象的集合
  */
 public List find(final HumanFile condition)
 {
  return this.getHibernateTemplate().executeFind(
    new HibernateCallback()
    {
     public Object doInHibernate(Session s) throws HibernateException{
      Criteria c = s.createCriteria(HumanFile.class);
      if (null != condition)
      {
       if (!Util.isNullOrBlank(condition.getFirstKindName())) {
        c.add(Restrictions
          .like("firstKindName", condition.getFirstKindName(),MatchMode.ANYWHERE));
       }
       if (!Util.isNullOrBlank(condition.getSecondKindName())) {
        c.add(Restrictions
          .like("secondKindName", condition.getSecondKindName(),MatchMode.ANYWHERE));
       }
       if (!Util.isNullOrBlank(condition.getThirdKindName())) {
        c.add(Restrictions
          .like("thirdKindName", condition.getThirdKindName(),MatchMode.ANYWHERE));
       }
       if (!Util.isNullOrBlank(condition.getHumanMajorKindName())) {
        c.add(Restrictions
          .like("humanMajorKindName", condition.getHumanMajorKindName(),MatchMode.ANYWHERE));
       }
       if (!Util.isNullOrBlank(condition.getHunmaMajorName())) {
        c.add(Restrictions
          .like("hunmaMajorName", condition.getHunmaMajorName(),MatchMode.ANYWHERE));
       }
       if (!Util.isNullOrBlank(condition.getStr_startTime())) {
        c.add(Restrictions
          .ge("registTime", Util.parseDate(condition.getStr_startTime())));
       }
       if (!Util.isNullOrBlank(condition.getStr_endTime())) {
        c.add(Restrictions
          .le("registTime", Util.parseDate(condition.getStr_endTime())));
       }
       if(!Util.isNullOrBlank(condition.getCheckStatus())){
        c.add(Restrictions
          .eq("checkStatus", condition.getCheckStatus()));
       }
       if(!Util.isNullOrBlank(condition.getHumanFileStatus().toString())){
        c.add(Restrictions
          .eq("humanFileStatus", condition.getHumanFileStatus()));
       }
      }
      c.addOrder(Order.asc("hufId"));
      return c.list();
     }
    }
  );
 }
 
 /**
  * 查询
  * @param key 关键字
  * @param delState 删除状态
  * @return
  */
 public List listByKey(String key,byte delState,byte chkState)
 {
  String sql = super.listByKey("HumanFile", key);
  sql += " and humanFileStatus = " + delState + " and checkStatus = " + chkState;
  
  return this.getHibernateTemplate().find(sql);
 }
}

、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、

 

package org.better.hr.dao;

import java.util.List;

import org.better.hr.comm.Util;
import org.better.hr.entity.HumanFileDig;
import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Restrictions;
import org.springframework.orm.hibernate3.HibernateCallback;

public class HumanFileDigDao extends BasicDao {
 /**
  * 查询方法，重载
  * @param condition 对象，该对象中设定了查询条件
  * @return　存放HumanFile对象的集合
  */
 public List find(final HumanFileDig condition)
 {
  return this.getHibernateTemplate().executeFind(
    new HibernateCallback()
    {
     public Object doInHibernate(Session s) throws HibernateException{
      Criteria c = s.createCriteria(HumanFileDig.class);
      if (null != condition)
      {
       if (!Util.isNullOrBlank(condition.getHumanId())) {
        c.add(Restrictions
          .eq("firstKindName", condition.getHumanId()));
       }
      }
      c.addOrder(Order.asc("hfdId"));
      return c.list();
     }
    }
  );
 }
 
 /**
  * 删除一组集合
  * @param conditions
  */
 public void delete(List conditions)
 {
  this.getHibernateTemplate().deleteAll(conditions);
 }
}

、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、

package org.better.hr.dao;

import java.io.Serializable;
import java.util.List;

import org.better.hr.comm.Util;
import org.better.hr.entity.SalaryStandard;
import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Restrictions;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

public class SalaryStandardDao extends HibernateDaoSupport {

 /**
  * 根据ID号返回该对象
  * @param id 主键id号
  * @return SalaryStandard 对象
  */
 public SalaryStandard load(Serializable id)
 { 
  return (SalaryStandard)(this.getHibernateTemplate().get(SalaryStandard.class, id));
 }
 
 /**
  * 查询方法,根据hbm.xml中的<sql-query>中的查询语句进行查询
  * @return 存放SalaryStandard对象的集合
  */
 public List find(){
  List list = this.getHibernateTemplate().find("select max(s.ssdId)from SalaryStandard s");
  return list;
 }
 
 /**
  * 查询方法，重载
  * @param condition 对象，该对象中设定了查询条件
  * @return　存放SalaryStandard对象的集合
  */
 public List find(final SalaryStandard condition)
 {
  return this.getHibernateTemplate().executeFind(
    new HibernateCallback()
    {
     public Object doInHibernate(Session s) throws HibernateException{
      Criteria c = s.createCriteria(SalaryStandard.class);
      if (null != condition)
      {
       if(!Util.isNullOrBlank(condition.getCheckStatus())){
        c.add(Restrictions
          .eq("checkStatus", condition.getCheckStatus()));
       }
       if (!Util.isNullOrBlank(condition.getStr_startTime())) {
        c.add(Restrictions
          .ge("registTime", Util.parseDate(condition.getStr_startTime())));
       }
       if (!Util.isNullOrBlank(condition.getStr_endTime())) {
        c.add(Restrictions
          .le("registTime", Util.parseDate(condition.getStr_endTime())));
       }
       if (!Util.isNullOrBlank(condition.getStandardId())) {
        c.add(Restrictions
          .eq("standardId", condition.getStandardId()));
       }
      }
      c.addOrder(Order.asc("ssdId"));
      return c.list();
     }
    }
  );
 }
 
 /**
  * 保存方法
  * @param item SalaryStandard对象
  */
 public void add(SalaryStandard item) { 
  
  this.getHibernateTemplate().save(item);
 }
 
 /**
  * 更新方法
  * @param item SalaryStandard对象
  */
 public void update(SalaryStandard item)
 {
  this.getHibernateTemplate().update(item);
 }
 
 /**
  * 删除方法
  * @param id 主键序列号
  */
 public void delete(java.io.Serializable key)
 {
  this.getHibernateTemplate().delete(this.load(key));
 }
 
 /**
  * 删除方法，重载
  * @param item SalaryStandard对象
  */
 public void delete(SalaryStandard item)
 {
  this.getHibernateTemplate().delete(item);
 }

}

、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、

 

package org.better.hr.dao;

import java.io.Serializable;
import java.util.List;

import org.better.hr.comm.Util;
import org.better.hr.entity.SalaryStandardDetails;
import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Restrictions;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

public class SalaryStandardDetailsDao extends HibernateDaoSupport {

 /**
  * 根据ID号返回该对象
  * @param id 主键id号
  * @return SalaryStandardDetails 对象
  */
 public SalaryStandardDetails load(Serializable id)
 { 
  return (SalaryStandardDetails)(this.getHibernateTemplate().get(SalaryStandardDetails.class, id));
 }
 
 /**
  * 查询方法,根据hbm.xml中的<sql-query>中的查询语句进行查询
  * @return 存放SalaryStandardDetails对象的集合
  */
 public List find(){
  List list = this.getHibernateTemplate().findByNamedQuery("search_sql");
  return list;
 }
 
 /**
  * 查询方法，重载
  * @param condition 对象，该对象中设定了查询条件
  * @return　存放SalaryStandardDetails对象的集合
  */
 public List find(final SalaryStandardDetails condition)
 {
  return this.getHibernateTemplate().executeFind(
    new HibernateCallback()
    {
     public Object doInHibernate(Session s) throws HibernateException{
      Criteria c = s.createCriteria(SalaryStandardDetails.class);
      if (null != condition)
      {
       if(!Util.isNullOrBlank(condition.getStandardId())){
        c.add(Restrictions
          .eq("standardId", condition.getStandardId()));
       }
      }
      c.addOrder(Order.asc("sdtId"));
      return c.list();
     }
    }
  );
 }
 
 /**
  * 保存方法
  * @param item SalaryStandardDetails对象
  */
 public void add(SalaryStandardDetails item) { 
  
  this.getHibernateTemplate().save(item);
 }
 
 /**
  * 更新方法
  * @param item SalaryStandardDetails对象
  */
 public void update(SalaryStandardDetails item)
 {
  this.getHibernateTemplate().update(item);
 }
 
 /**
  * 删除方法
  * @param id 主键序列号
  */
 public void delete(java.io.Serializable key)
 {
  this.getHibernateTemplate().delete(this.load(key));
 }
 
 /**
  * 删除方法，重载
  * @param item SalaryStandardDetails对象
  */
 public void delete(SalaryStandardDetails item)
 {
  this.getHibernateTemplate().delete(item);
 }

}

、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、

package org.better.hr.dao;

import java.io.Serializable;
import java.util.List;

import org.better.hr.comm.Util;
import org.better.hr.entity.Training;
import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Restrictions;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

public class TrainingDao extends BasicDao {

 /**
  * 查询方法,根据hbm.xml中的<sql-query>中的查询语句进行查询
  * @return 存放Training对象的集合
  */
 public List find(){
  List list = this.getHibernateTemplate().find("select max(s.ssdId)from SalaryStandard s");
  return list;
 }
 
 /**
  * 查询方法，重载
  * @param condition 对象，该对象中设定了查询条件
  * @return　存放Training对象的集合
  */
 public List find(final Training condition)
 {
  return this.getHibernateTemplate().executeFind(
    new HibernateCallback()
    {
     public Object doInHibernate(Session s) throws HibernateException{
      Criteria c = s.createCriteria(Training.class);
      if (null != condition)
      {

      }
      c.addOrder(Order.asc("traId"));
      return c.list();
     }
    }
  );
 }
}

、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、

package org.better.hr.dao;

import java.io.Serializable;
import java.util.List;

import org.better.hr.comm.Util;
import org.better.hr.entity.Users;
import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Restrictions;
import org.springframework.orm.hibernate3.HibernateCallback;

public class UsersDao extends BasicDao {

 
 /**
  * 查询方法,根据hbm.xml中的<sql-query>中的查询语句进行查询
  * @return 存放Users对象的集合
  */
 public List find(){
  List list = this.getHibernateTemplate().find("");
  return list;
 }
 
 /**
  * 查询方法，重载
  * @param condition 对象，该对象中设定了查询条件
  * @return　存放Users对象的集合
  */
 public List find(final Users condition)
 {
  return this.getHibernateTemplate().executeFind(
    new HibernateCallback()
    {
     public Object doInHibernate(Session s) throws HibernateException{
      Criteria c = s.createCriteria(Users.class);
      if (null != condition)
      {
       if(!Util.isNullOrBlank(condition.getUName())){
        c.add(Restrictions
          .eq("UName", condition.getUName()));
       }
       if(!Util.isNullOrBlank(condition.getUPassword())){
        c.add(Restrictions
          .eq("UPassword", condition.getUPassword()));
       }
      }
      c.addOrder(Order.asc("UId"));
      return c.list();
     }
    }
  );
 }
}

、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、

 

 

 

 

 

 

 

 

 

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值