gistfile1.java

package com.nextzy.nbc.admin.dao.impl;

import java.util.List;

import org.hibernate.Criteria;
import org.hibernate.FetchMode;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.MatchMode;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Property;
import org.hibernate.criterion.Restrictions;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
import org.springframework.stereotype.Repository;



/** Palakorn Nakphong @Nextzy Technologies */

@Repository
public class UserDao extends HibernateDaoSupport implements IUserDao{

	@Autowired
	private GenericEntityDao genericEntityDao;
	
	@Autowired
	private GenericFinderDao genericFinderDao;
	


	protected Session session;

	@Autowired
	public void setDummySessionFactory(SessionFactory sessionFactory) {
		setSessionFactory(sessionFactory);
		session = this.getHibernateTemplate().getSessionFactory().openSession();
	}
	
  	@Override
	public boolean addUserSection(Long[] userSectionArr, User user) throws Exception{
		UserSection userSection;
		Section section;
		for(int i=0;i<userSectionArr.length;i++){
			userSection = new UserSection();
			userSection.setUser(user);
			section = new Section();
			section.setId(userSectionArr[i]);
			userSection.setSection(section);
			genericEntityDao.save(userSection);		
		}
		return true;
	}

	
	@Override
	public boolean deleteAllUserSection(User user) throws Exception{
		List<UserSection> userSection;
		DetachedCriteria detachedCriteria = DetachedCriteria.forClass(UserSection.class);
			detachedCriteria.add(Restrictions.eq("user_id", user.getId()));
			userSection = genericFinderDao.findByCriteria(detachedCriteria);
			genericEntityDao.deleteAll(userSection);		
		
		return true;
	}
	@Override
	@SuppressWarnings("unchecked")
	public List<User> getUsers() {
		int pageNumber = 1;
		int pageSize = 10;
		
		List<User> result = session.getSessionFactory().getCurrentSession().createCriteria(User.class).setFirstResult((pageNumber - 1) * pageSize)
				.setMaxResults(pageSize).list();
		return result;
	}	
	
	@Override
	public List<User> getUsers(int offset, int pageSize) {
		List<User> result = session.getSessionFactory().getCurrentSession().createCriteria(User.class).setFirstResult((offset - 1) * pageSize).setMaxResults(pageSize).list();
		
		return result;
	}
	@Override
	public List<User> getUsers(int offset, int pageSize, String query,
			Integer orderColumn, String orderDirection) {
		Criteria criteria = session.getSessionFactory().getCurrentSession().createCriteria(User.class);
		
		this.prepareOrder(criteria, orderColumn, orderDirection);
		this.prepareQuery(criteria, query);
		criteria.setFirstResult((offset - 1) * pageSize).setMaxResults(pageSize);
		List<User> result = criteria.list();
		return result;
	}
	@Override
	public long getUsersCount() {
		Criteria criteria = session.getSessionFactory().getCurrentSession().createCriteria(User.class).setProjection(Projections.count("id"));
		criteria.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY);
		long count = (long) criteria.uniqueResult();

		return count;
	}
	@Override
	public long getUsersCount(String query) {
		Criteria criteria = session.getSessionFactory().getCurrentSession().createCriteria(User.class).setProjection(Projections.count("id"));
		criteria.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY);
		long count = (long) this.prepareQuery(criteria, query).uniqueResult();
		return count;
	}
	
	private boolean isInteger(String text)
	{
		if (text.length() == 0)
			return false;

		for (int i = 0; i < text.length(); ++i)
		{
			if (Character.isDigit(text.charAt(i)) == false)
				return false;
		}
		return true;
	}

	private Criteria prepareOrder(Criteria criteria, int orderColumn, String orderDirection)
	{
		String columnName = null;
		switch (orderColumn)
		{
			case 0:
				columnName = "id";
				break;

			case 1:
				columnName = "employeeCode";
				break;

			case 2:
				columnName = "firstname";
				break;

			case 3:
				columnName = "lastname";
				break;

			case 4:
				columnName = "internalTel";
				break;
			
			case 5:
				columnName = "login";
				break;
			
			case 6:
				columnName = "p.name";
				break;
				
			case 7:
				columnName = "di.name";
				break;
				
			case 8:
				columnName = "de.name";
				break;
		}

		if (columnName != null){
			Property property = Property.forName(columnName);
			if ("asc".equals(orderDirection))
				criteria.addOrder(property.asc());
			else
				criteria.addOrder(property.desc());
		}
		return criteria;
	}

	private Criteria prepareQuery(Criteria criteria, String query)
	{
		/*criteria.setFetchMode("position", FetchMode.JOIN);
		criteria.setFetchMode("userSections", FetchMode.JOIN);*/
		criteria.createAlias("position", "p");
		criteria.createAlias("userSections", "us");
		criteria.createAlias("us.section", "s");
		criteria.createAlias("s.department", "de");
		criteria.createAlias("de.division", "di");
		criteria.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY);
		Criterion employeeCode = Restrictions.like("employeeCode", query, MatchMode.ANYWHERE);
		Criterion firstname = Restrictions.like("firstname", query, MatchMode.ANYWHERE);
		Criterion lastname = Restrictions.like("lastname", query, MatchMode.ANYWHERE);
		Criterion internalTel = Restrictions.like("internalTel", query, MatchMode.ANYWHERE);
		Criterion login = Restrictions.like("login", query, MatchMode.ANYWHERE);
		Criterion positionName = Restrictions.like("p.name", query, MatchMode.ANYWHERE);
		Criterion divisionName = Restrictions.like("di.name", query, MatchMode.ANYWHERE);
		Criterion departmentName = Restrictions.like("de.name", query, MatchMode.ANYWHERE);
		Criterion disjuction = Restrictions.or(employeeCode, firstname);
		disjuction = Restrictions.or(disjuction, lastname);
		disjuction = Restrictions.or(disjuction, internalTel);
		disjuction = Restrictions.or(disjuction, login);
		disjuction = Restrictions.or(disjuction, positionName);
		disjuction = Restrictions.or(disjuction, divisionName);
		disjuction = Restrictions.or(disjuction, departmentName);
		if (this.isInteger(query))
		{
			Criterion id = Restrictions.eq("id", Long.valueOf(query));
			disjuction = Restrictions.or(disjuction, id);
		}
		return criteria.add(disjuction);
	}
}