GenericDAO.java

package fi.insomnia.intra.dao;

import java.lang.reflect.ParameterizedType;
import java.math.BigInteger;
import java.util.List;

import javax.persistence.EntityManager;
import javax.persistence.EntityNotFoundException;
import javax.persistence.Query;

import org.slf4j.LoggerFactory;

import fi.insomnia.intra.db.BaseEntity;

public abstract class GenericDAO<T extends BaseEntity> implements IGenericDao<T> {

    private EntityManager entityManager;
    private Class<T> clazz;
    private ExternalEntityManagerFactory entityManagerfactory;
    private static final org.slf4j.Logger logger = LoggerFactory.getLogger(GenericDAO.class);

    @SuppressWarnings("unchecked")
    public GenericDAO(EntityManager em) {
	super();
	setEntityManager(em);
	clazz = (Class<T>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0];
    }

    protected GenericDAO(Class<T> clazz) {
	super();
	this.clazz = clazz;
	// clazz = (Class<T>) ((ParameterizedType)
	// getClass().getGenericSuperclass()).getActualTypeArguments()[0];
    }

    protected void setEntityManagerFactory(ExternalEntityManagerFactory emf) {
	entityManagerfactory = emf;
    }

    protected EntityManager getEntityManager() {
	EntityManager ret = entityManager;
	if (entityManagerfactory != null) {
	    logger.debug("External entity manaer factory found. Returning entity from there");
	    ret = entityManagerfactory.getExternalEntity();
	}
	logger.debug("returning entityManager: {}", ret);
	return ret;
    }

    /*
     * (non-Javadoc)
     * @see fi.insomnia.intra.db.IGenericDao#load(java.math.BigInteger)
     */
    public final T load(BigInteger id) throws EntityNotFoundException {
	T entity = get(id);
	if (entity == null) {
	    throw new EntityNotFoundException("entity " + clazz + "#" + id + " was not found");
	}
	return entity;
    }

    /*
     * (non-Javadoc)
     * @see fi.insomnia.intra.db.IGenericDao#get(java.math.BigInteger)
     */
    public final T get(BigInteger id) {
	return (T) getEntityManager().find(clazz, id);
    }

    /*
     * (non-Javadoc)
     * @see fi.insomnia.intra.db.IGenericDao#save(T)
     */
    public void save(final T object) {
	logger.debug("Saving object {}", object);
	if (object.getId() != null) {
	    getEntityManager().merge(object);
	} else {
	    getEntityManager().persist(object);
	}
    }

    /*
     * (non-Javadoc)
     * @see fi.insomnia.intra.db.IGenericDao#delete(T)
     */
    public void delete(final T object) throws UnsupportedOperationException {

	getEntityManager().remove(object);

    }

    /*
     * (non-Javadoc)
     * @see fi.insomnia.intra.db.IGenericDao#refresh(T)
     */
    public final void refresh(final T entity) {
	getEntityManager().refresh(entity);
    }

    /*
     * (non-Javadoc)
     * @see fi.insomnia.intra.db.IGenericDao#flushAndClear()
     */
    public final void flushAndClear() {
	getEntityManager().flush();
	getEntityManager().clear();
    }

    /*
     * (non-Javadoc)
     * @see fi.insomnia.intra.db.IGenericDao#delete(java.math.BigInteger)
     */
    public void delete(BigInteger id) throws UnsupportedOperationException {
	delete(load(id));
    }

    protected abstract String getAllNamedQuery();

    public abstract long getAllCount();

    /*
     * (non-Javadoc)
     * @see fi.insomnia.intra.db.IGenericDao#getAllQuery()
     */
    public Query getAllQuery() {
	return getEntityManager().createNamedQuery(getAllNamedQuery());
    }

    public Query getAllCountQuery() {
	return getEntityManager().createNamedQuery(getAllNamedQuery());
    }

    /*
     * (non-Javadoc)
     * @see fi.insomnia.intra.db.IGenericDao#getAll()
     */
    @SuppressWarnings("unchecked")
    public List<T> getAll() {
	return getAllQuery().getResultList();
    }

    private void setEntityManager(EntityManager entityManager) {
	this.entityManager = entityManager;
    }

    @SuppressWarnings("unchecked")
    @Override
    public List<T> getItems(IPagingStatus paging) {
	Query q = getAllQuery();
	long allCount = this.getAllCount();
	return getPagination(paging, q, allCount);
    }

    protected List<T> getPagination(IPagingStatus paging, Query q, long allCount) {
	paging.setTotalHits(allCount);

	int firstresult = paging.getPagesize() * paging.getPage();
	logger.info("Pagesize: {}, {}", paging.getPagesize(), firstresult);
	q.setMaxResults(paging.getPagesize());

	q.setFirstResult(firstresult);

	List ret = q.getResultList();

	logger.info("Retcount {}", ret.size());
	return ret;

    }

}