BaseManager

package org.neo.core.base;

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

import javax.ejb.TransactionAttribute;
import javax.ejb.TransactionAttributeType;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;
import javax.persistence.Table;

import org.springframework.transaction.annotation.Transactional;

@Transactional
public class BaseManager<E extends IEntity> implements IManager<E> {

    @PersistenceContext
    protected EntityManager em;
    private Class entityClass = null;
    private String tableName = "";
    private String entityName = "";
    private String fieldList = "";
    private String tableList = "";
    private String joinList = "";

    @SuppressWarnings("unchecked")
	public BaseManager(Class en) {
        this.entityClass = en;
        Table tableAnnotation = (Table)en.getAnnotation(Table.class);
        this.tableName = tableAnnotation.name();
        this.tableList = this.tableName;
        this.entityName = this.entityClass.getSimpleName();
    }

    public String getFieldList() {
        return fieldList;
    }

    public void setFieldList(String fieldList) {
        this.fieldList = fieldList;
    }

    public String getJoinList() {
        return joinList;
    }

    public void setJoinList(String joinList) {
        this.joinList = joinList;
    }

    public String getTableList() {
        return tableList;
    }

    public void setTableList(String tableList) {
        this.tableList = tableList;
    }

    public void remove(E entity) {
        em.remove(entity);
    }

    public void insert(E entity) {
        em.persist(entity);
    }

    public void update(E entity) {
        entity = em.merge(entity);
        em.persist(entity);
    }

    public void delete (String strFilter) {
        String strSQL = SQLHelper.getDeleteByFilterSQL(this.entityName,strFilter);
    	em.createQuery(strSQL).executeUpdate();
    }    

    @SuppressWarnings("unchecked")
    @TransactionAttribute(TransactionAttributeType.NOT_SUPPORTED)
	public E findByPKFilter(Filter filter) {
    	E object = null;
    	List<E> list = em.createNativeQuery(SQLHelper.getSelectFilterSQL(this,filter), this.entityClass).getResultList();
    	if(list.size()>0) {
    		object = list.get(0);
    	}
    	return object;
    }
    
    @SuppressWarnings("unchecked")
    @TransactionAttribute(TransactionAttributeType.NOT_SUPPORTED)
    public E find(Class<E> entityClass, Serializable pk) {
        return em.find(entityClass, pk);
    }

    @SuppressWarnings("unchecked")
    @TransactionAttribute(TransactionAttributeType.NOT_SUPPORTED)
    public E find(Serializable pk) {
        return (E) em.find(entityClass, pk);
    }

    @SuppressWarnings("unchecked")
    @TransactionAttribute(TransactionAttributeType.NOT_SUPPORTED)    
    public List<E> findAll() {
        return em.createNativeQuery(SQLHelper.getSelectAllSQL(this), this.entityClass).getResultList();
    }

    public int findCount() {
    	int intCount = 0;
        Object count = em.createNativeQuery(SQLHelper.getSelectCountSQL(this)).getSingleResult();
        if (count instanceof java.math.BigDecimal) {
        	java.math.BigDecimal bdCount = (java.math.BigDecimal)count;
        	intCount = bdCount.intValue();
        } else if (count instanceof java.lang.Long){
        	java.lang.Long  lgCount = (Long)count;
        	intCount = lgCount.intValue();
        }
        return intCount;
    }

    public int findCount(Filter filter) {
    	String strSQL = SQLHelper.getSelectFilterSQL(this, filter);
    	String strCountSQL = "";
    	if (strSQL.toLowerCase().indexOf("distinct")>=0){
    		strCountSQL =  " select count(*) from (" + strSQL + ")";
    	}else{
    		strCountSQL = SQLHelper.getSelectCountFilterSQL(this, filter);
    	}
    	int intCount = 0;    	
    	Object count =  em.createNativeQuery(strCountSQL).getSingleResult();
        if (count instanceof java.math.BigDecimal) {
        	java.math.BigDecimal bdCount = (java.math.BigDecimal)count;
        	intCount = bdCount.intValue();
        } else if (count instanceof java.lang.Long){
        	java.lang.Long  lgCount = (Long)count;
        	intCount = lgCount.intValue();
        }
        return intCount;
    }

    @SuppressWarnings("unchecked")
    @TransactionAttribute(TransactionAttributeType.NOT_SUPPORTED)    
    public List<E> findPart(Filter filter) {
        Query query = em.createNativeQuery(SQLHelper.getSelectFilterSQL(this, filter),this.entityClass);
        if(filter.getLimit()==0 && filter.getStart() ==0 ){
        	
        }else{
        	query.setMaxResults(filter.getLimit()).setFirstResult(filter.getStart());
        }
        return query.getResultList();
    }
    
    @SuppressWarnings("unchecked")    
    public List<Map> findMap(Filter filter) {
    	Query query = em.createNativeQuery(SQLHelper.getSelectFilterSQL(this, filter), HashMap.class);
        if(filter.getLimit()==0 && filter.getStart() ==0 ){
        }else{
        	query.setMaxResults(filter.getLimit()).setFirstResult(filter.getStart());
        }
        List list = query.getResultList();    	
        return list;
    }
    
    @SuppressWarnings("unchecked")    
    public List<Object[]> findArray(Filter filter) {
    	Query query = em.createNativeQuery(SQLHelper.getSelectFilterSQL(this, filter));
        if(filter.getLimit()==0 && filter.getStart() ==0 ){
        }else{
        	query.setMaxResults(filter.getLimit()).setFirstResult(filter.getStart());
        }
        return query.getResultList();    	
    }    
}