EDIT

/**

* Copyright (C) 2007 EDIT

* European Distributed Institute of Taxonomy

* http://www.e-taxonomy.eu

*

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.cdm.persistence.dao.hibernate.common;

import java.lang.reflect.Field;

import java.util.ArrayList;

import java.util.Collection;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.UUID;

import org.apache.log4j.Logger;

import org.apache.lucene.search.Sort;

import org.apache.lucene.search.SortField;

import org.hibernate.Criteria;

import org.hibernate.FlushMode;

import org.hibernate.HibernateException;

import org.hibernate.LockOptions;

import org.hibernate.NonUniqueObjectException;

import org.hibernate.Query;

import org.hibernate.Session;

import org.hibernate.criterion.Criterion;

import org.hibernate.criterion.DetachedCriteria;

import org.hibernate.criterion.Example;

import org.hibernate.criterion.Example.PropertySelector;

import org.hibernate.criterion.Order;

import org.hibernate.criterion.ProjectionList;

import org.hibernate.criterion.Projections;

import org.hibernate.criterion.Restrictions;

import org.hibernate.envers.query.AuditQuery;

import org.hibernate.metadata.ClassMetadata;

import org.hibernate.search.FullTextQuery;

import org.hibernate.type.Type;

import org.joda.time.DateTime;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.dao.DataAccessException;

import org.springframework.dao.InvalidDataAccessApiUsageException;

import org.springframework.security.core.Authentication;

import org.springframework.security.core.context.SecurityContextHolder;

import org.springframework.stereotype.Repository;

import org.springframework.util.ReflectionUtils;

import eu.etaxonomy.cdm.model.common.CdmBase;

import eu.etaxonomy.cdm.model.common.User;

import eu.etaxonomy.cdm.model.common.VersionableEntity;

import eu.etaxonomy.cdm.persistence.dao.common.ICdmEntityDao;

import eu.etaxonomy.cdm.persistence.dao.common.Restriction;

import eu.etaxonomy.cdm.persistence.dao.initializer.IBeanInitializer;

import eu.etaxonomy.cdm.persistence.dto.MergeResult;

import eu.etaxonomy.cdm.persistence.hibernate.PostMergeEntityListener;

import eu.etaxonomy.cdm.persistence.hibernate.replace.ReferringObjectMetadata;

import eu.etaxonomy.cdm.persistence.hibernate.replace.ReferringObjectMetadataFactory;

import eu.etaxonomy.cdm.persistence.query.Grouping;

import eu.etaxonomy.cdm.persistence.query.MatchMode;

import eu.etaxonomy.cdm.persistence.query.OrderHint;

/**

 * @author a.mueller

 * FIXME CdmEntityDaoBase is abstract, can it be annotated with @Repository?

 */

@Repository

public abstract class CdmEntityDaoBase<T extends CdmBase> extends DaoBase implements ICdmEntityDao<T> {

    private static final Logger logger = Logger.getLogger(CdmEntityDaoBase.class);

    protected int flushAfterNo = 1000; //large numbers may cause synchronisation errors when commiting the session !!

    protected Class<T> type;

//    protected Version version = Configuration.luceneVersion;

    @Autowired

//	@Qualifier("defaultBeanInitializer")

    protected IBeanInitializer defaultBeanInitializer;

    public void setDefaultBeanInitializer(IBeanInitializer defaultBeanInitializer) {

        this.defaultBeanInitializer = defaultBeanInitializer;

    }

    @Autowired

    private ReferringObjectMetadataFactory referringObjectMetadataFactory;

    public CdmEntityDaoBase(Class<T> type){

        this.type = type;

        logger.debug("Creating DAO of type [" + type.getSimpleName() + "]");

    }

    @Override

    public void lock(T t, LockOptions lockOptions) {

        getSession().buildLockRequest(lockOptions).lock(t);

    }

    @Override

    public void refresh(T t, LockOptions lockOptions, List<String> propertyPaths) {

        getSession().refresh(t, lockOptions);

        defaultBeanInitializer.initialize(t, propertyPaths);

    }

    //TODO this method should be moved to a concrete class (not typed)

    public UUID saveCdmObj(CdmBase cdmObj) throws DataAccessException  {

        getSession().saveOrUpdate(cdmObj);

        return cdmObj.getUuid();

    }

    //TODO: Replace saveCdmObj() by saveCdmObject_

    private UUID saveCdmObject_(T cdmObj){

        getSession().saveOrUpdate(cdmObj);

        return cdmObj.getUuid();

    }

    //TODO: Use everywhere CdmEntityDaoBase.saveAll() instead of ServiceBase.saveCdmObjectAll()?

    //TODO: why does this use saveCdmObject_ which actually savesOrUpdateds data ?

    @Override

    public Map<UUID, T> saveAll(Collection<T> cdmObjCollection){

        int types = cdmObjCollection.getClass().getTypeParameters().length;

        if (types > 0){

            if (logger.isDebugEnabled()){logger.debug("ClassType: + " + cdmObjCollection.getClass().getTypeParameters()[0]);}

        }

        Map<UUID, T> resultMap = new HashMap<>();

        Iterator<T> iterator = cdmObjCollection.iterator();

        int i = 0;

        while(iterator.hasNext()){

            if ( ( (i % 2000) == 0) && (i > 0)   ){logger.debug("Saved " + i + " objects" );}

            T cdmObj = iterator.next();

            UUID uuid = saveCdmObject_(cdmObj);

            if (logger.isDebugEnabled()){logger.debug("Save cdmObj: " + (cdmObj == null? null: cdmObj.toString()));}

            resultMap.put(uuid, cdmObj);

            i++;

            if ( (i % flushAfterNo) == 0){

                try{

                    if (logger.isDebugEnabled()){logger.debug("flush");}

                    flush();

                }catch(Exception e){

                    logger.error("An exception occurred when trying to flush data");

                    e.printStackTrace();

                    throw new RuntimeException(e);

                }

            }

        }

        if ( logger.isInfoEnabled() ){logger.info("Saved " + i + " objects" );}

        return resultMap;

    }

    private UUID saveOrUpdateCdmObject(T cdmObj){

        getSession().saveOrUpdate(cdmObj);

        return cdmObj.getUuid();

    }

    @Override

    public Map<UUID, T> saveOrUpdateAll(Collection<T> cdmObjCollection){

        int types = cdmObjCollection.getClass().getTypeParameters().length;

        if (types > 0){

            if (logger.isDebugEnabled()){logger.debug("ClassType: + " + cdmObjCollection.getClass().getTypeParameters()[0]);}

        }

        Map<UUID, T> resultMap = new HashMap<>();

        Iterator<T> iterator = cdmObjCollection.iterator();

        int i = 0;

        while(iterator.hasNext()){

            if ( ( (i % 2000) == 0) && (i > 0)   ){logger.debug("Saved " + i + " objects" );}

            T cdmObj = iterator.next();

            UUID uuid = saveOrUpdateCdmObject(cdmObj);

            if (logger.isDebugEnabled()){logger.debug("Save cdmObj: " + (cdmObj == null? null: cdmObj.toString()));}

            resultMap.put(uuid, cdmObj);

            i++;

            if ( (i % flushAfterNo) == 0){

                try{

                    if (logger.isDebugEnabled()){logger.debug("flush");}

                    flush();

                }catch(Exception e){

                    logger.error("An exception occurred when trying to flush data");

                    e.printStackTrace();

                    throw new RuntimeException(e);

                }

            }

        }

        if ( logger.isInfoEnabled() ){logger.info("Saved " + i + " objects" );}

        return resultMap;

    }

    @Override

    public T replace(T x, T y) {

        if(x.equals(y)) {

            return y;

        }

        Class<?> commonClass = x.getClass();

        if(y != null) {

            while(!commonClass.isAssignableFrom(y.getClass())) {

                if(commonClass.equals(type)) {

                    throw new RuntimeException();

                }

                commonClass = commonClass.getSuperclass();

            }

        }

        getSession().merge(x);

        Set<ReferringObjectMetadata> referringObjectMetas = referringObjectMetadataFactory.get(x.getClass());

        for(ReferringObjectMetadata referringObjectMetadata : referringObjectMetas) {

          List<CdmBase> referringObjects = referringObjectMetadata.getReferringObjects(x, getSession());

          for(CdmBase referringObject : referringObjects) {

            try {

                referringObjectMetadata.replace(referringObject,x,y);

                getSession().update(referringObject);

            } catch (IllegalArgumentException e) {

                throw new RuntimeException(e.getMessage(),e);

            } catch (IllegalAccessException e) {

                throw new RuntimeException(e.getMessage(),e);

            }

          }

        }

        return y;

    }

    @Override

    public Session getSession() throws DataAccessException {

        return super.getSession();

    }

    @Override

    public void clear() throws DataAccessException {

        Session session = getSession();

        session.clear();

        if (logger.isDebugEnabled()){logger.debug("dao clear end");}

    }

    @Override

    public MergeResult<T> merge(T transientObject, boolean returnTransientEntity) throws DataAccessException {

        Session session = getSession();

        PostMergeEntityListener.addSession(session);

        MergeResult<T> result = null;

        try {

            @SuppressWarnings("unchecked")

            T persistentObject = (T)session.merge(transientObject);

            if (logger.isDebugEnabled()){logger.debug("dao merge end");}

            if(returnTransientEntity) {

                if(transientObject != null && persistentObject != null) {

                    transientObject.setId(persistentObject.getId());

                }

                result = new MergeResult(transientObject, PostMergeEntityListener.getNewEntities(session));

            } else {

                result = new MergeResult(persistentObject, null);

            }

            return result;

        } finally {

            PostMergeEntityListener.removeSession(session);

        }

    }

    @Override

    public T merge(T transientObject) throws DataAccessException {

        Session session = getSession();

        @SuppressWarnings("unchecked")

		T persistentObject = (T)session.merge(transientObject);

        if (logger.isDebugEnabled()){logger.debug("dao merge end");}

        return persistentObject;

    }

    @Override

    public UUID saveOrUpdate(T transientObject) throws DataAccessException  {

        if (transientObject == null){

        	logger.warn("Object to save should not be null. NOP");

        	return null;

        }

    	try {

            if (logger.isDebugEnabled()){logger.debug("dao saveOrUpdate start...");}

            if (logger.isDebugEnabled()){logger.debug("transientObject(" + transientObject.getClass().getSimpleName() + ") ID:" + transientObject.getId() + ", UUID: " + transientObject.getUuid()) ;}

            Session session = getSession();

            if(transientObject.getId() != 0 && VersionableEntity.class.isAssignableFrom(transientObject.getClass())) {

                VersionableEntity versionableEntity = (VersionableEntity)transientObject;

                versionableEntity.setUpdated(new DateTime());

                Authentication authentication = SecurityContextHolder.getContext().getAuthentication();

                if(authentication != null && authentication.getPrincipal() != null && authentication.getPrincipal() instanceof User) {

                  User user = (User)authentication.getPrincipal();

                  versionableEntity.setUpdatedBy(user);

                }

            }

            session.saveOrUpdate(transientObject);

            if (logger.isDebugEnabled()){logger.debug("dao saveOrUpdate end");}

            return transientObject.getUuid();

        } catch (NonUniqueObjectException e) {

            logger.error("Error in CdmEntityDaoBase.saveOrUpdate(obj). ID="+e.getIdentifier()+". Class="+e.getEntityName());

            logger.error(e.getMessage());

            e.printStackTrace();

            throw e;

        } catch (HibernateException e) {

            e.printStackTrace();

            throw e;

        }

    }

    @Override

    public T save(T newInstance) throws DataAccessException {

        if (newInstance == null){

        	logger.warn("Object to save should not be null. NOP");

        	return null;

        }

    	getSession().save(newInstance);

        return newInstance;

    }

    @Override

    public UUID update(T transientObject) throws DataAccessException {

        if (transientObject == null){

        	logger.warn("Object to update should not be null. NOP");

        	return null;

        }

    	getSession().update(transientObject);

        return transientObject.getUuid();

    }

    @Override

    public UUID refresh(T persistentObject) throws DataAccessException {

        getSession().refresh(persistentObject);

        return persistentObject.getUuid();

    }

    @Override

    public UUID delete(T persistentObject) throws DataAccessException {

        if (persistentObject == null){

            logger.warn(type.getName() + " was 'null'");

            return null;

        }

        // Merge the object in if it is detached

        //

        // I think this is preferable to catching lazy initialization errors

        // as that solution only swallows and hides the exception, but doesn't

        // actually solve it.

       persistentObject = (T) getSession().merge(persistentObject);

        getSession().delete(persistentObject);

        return persistentObject.getUuid();

    }

	@Override

    public T findById(int id) throws DataAccessException {

        return getSession().get(type, id);

    }

    @Override

    public T findByUuid(UUID uuid) throws DataAccessException{

        Session session = getSession();

        Criteria crit = session.createCriteria(type);

        crit.add(Restrictions.eq("uuid", uuid));

        crit.addOrder(Order.desc("created"));

        @SuppressWarnings("unchecked")

		List<T> results = crit.list();

        Set<T> resultSet = new HashSet<>();

        resultSet.addAll(results);

        if (resultSet.isEmpty()){

            return null;

        }else{

            if(resultSet.size() > 1){

                logger.error("findByUuid() delivers more than one result for UUID: " + uuid);

            }

            return results.get(0);

        }

    }

    @Override

    public T findByUuidWithoutFlush(UUID uuid) throws DataAccessException{

    	Session session = getSession();

    	FlushMode currentFlushMode = session.getFlushMode();

    	try {

    		// set flush mode to manual so that the session does not flush

    		// when before performing the query

    		session.setFlushMode(FlushMode.MANUAL);

    		Criteria crit = session.createCriteria(type);

    		crit.add(Restrictions.eq("uuid", uuid));

    		crit.addOrder(Order.desc("created"));

    		@SuppressWarnings("unchecked")

			List<T> results = crit.list();

    		if (results.isEmpty()){

    			return null;

    		}else{

    			if(results.size() > 1){

    				logger.error("findByUuid() delivers more than one result for UUID: " + uuid);

    			}

    			return results.get(0);

    		}

    	} finally {

    		// set back the session flush mode

    		if(currentFlushMode != null) {

    			session.setFlushMode(currentFlushMode);

    		}

    	}

    }

    @Override

    public List<T> loadList(Collection<Integer> ids,  List<String> propertyPaths) throws DataAccessException {

        if (ids.isEmpty()) {

            return new ArrayList<T>(0);

        }

        Criteria criteria = prepareList(ids, null, null, null, "id");

        if (logger.isDebugEnabled()){logger.debug(criteria.toString());}

         @SuppressWarnings("unchecked")

		List<T> result = criteria.list();

         defaultBeanInitializer.initializeAll(result, propertyPaths);

         return result;

     }

    @Override

    public List<T> list(Collection<UUID> uuids, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) throws DataAccessException {

        if (uuids == null || uuids.isEmpty()){

            return new ArrayList<>();

        }

        Criteria criteria = prepareList(uuids, pageSize, pageNumber, orderHints, "uuid");

        @SuppressWarnings("unchecked")

		List<T> result = criteria.list();

        defaultBeanInitializer.initializeAll(result, propertyPaths);

        return result;

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public  List<T> list(Class<? extends T> type, List<Restriction<?>> restrictions,

            Integer limit, Integer start, List<OrderHint> orderHints, List<String> propertyPaths) {

        Criteria criteria = criterionForType(type);

        addRestrictions(restrictions, criteria);

        addLimitAndStart(limit, start, criteria);

        addOrder(criteria, orderHints);

        @SuppressWarnings("unchecked")

        List<T> result = criteria.list();

        defaultBeanInitializer.initializeAll(result, propertyPaths);

        return result;

    }

    /**

     * @param restrictions

     * @param criteria

     */

    private void addRestrictions(List<Restriction<?>> restrictions, Criteria criteria) {

        List<Criterion> perProperty = new ArrayList<>(restrictions.size());

        Map<String, String> aliases = new HashMap<>();

        for(Restriction<?> propMatchMode : restrictions){

            Collection<? extends Object> values = propMatchMode.getValues();

            if(values != null && !values.isEmpty()){

                Criterion[] predicates = new Criterion[values.size()];

                int i = 0;

                for(Object v : values){

                    String propertyPath = propMatchMode.getPropertyName();

                    // create aliases if the propertyName is a dot separated property path

                    String[] props =  propertyPath.split("\\.");

                    String aliasKey = "";

                    String alias = null;

                    for(int p = 0; p < props.length -1; p++){

                        if(!aliases.containsKey(aliasKey + "_" + props[p])){

                            alias = props[p] + aliases.size();

                            aliases.put(aliasKey, alias);

                            criteria.createAlias(props[p], alias);

                        }

                    }

                    String propertyName = alias != null ? alias + "." + props[props.length -1] : propertyPath;

                    predicates[i++] = createRestriction(propertyName, v, propMatchMode.getMatchMode());

                }

                perProperty.add(Restrictions.or(predicates));

            }

        }

        if(!perProperty.isEmpty()){

            criteria.add(Restrictions.and(perProperty.toArray(new Criterion[perProperty.size()])));

        }

    }

    /**

     * @param propertyName

     * @param value

     * @param matchMode

     * @param criteria

     * @return

     */

    private Criterion createRestriction(String propertyName, Object value, MatchMode matchMode) {

        Criterion restriction;

        if(matchMode == null) {

            restriction = Restrictions.eq(propertyName, value);

        } else if(value == null) {

            restriction = Restrictions.isNull(propertyName);

        } else if(!(value instanceof String)) {

            restriction = Restrictions.eq(propertyName, value);

        } else {

            String queryString = (String)value;

            if(matchMode == MatchMode.BEGINNING) {

                restriction = Restrictions.ilike(propertyName, queryString, org.hibernate.criterion.MatchMode.START);

            } else if(matchMode == MatchMode.END) {

                restriction = Restrictions.ilike(propertyName, queryString, org.hibernate.criterion.MatchMode.END);

            } else if(matchMode == MatchMode.EXACT) {

                restriction = Restrictions.ilike(propertyName, queryString, org.hibernate.criterion.MatchMode.EXACT);

            } else {

                restriction = Restrictions.ilike(propertyName, queryString, org.hibernate.criterion.MatchMode.ANYWHERE);

            }

        }

        return restriction;

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public int count(Class<? extends T> type, List<Restriction<?>> restrictions) {

        Criteria criteria = criterionForType(type);

        addRestrictions(restrictions, criteria);

        criteria.setProjection(Projections.projectionList().add(Projections.rowCount()));

        //since hibernate 4 (or so) uniqueResult returns Long, not Integer, therefore needs

        //to be casted. Think about returning long rather then int!

        return ((Number) criteria.uniqueResult()).intValue();

    }

    /**

     * @param uuids

     * @param pageSize

     * @param pageNumber

     * @param orderHints

     * @param propertyName

     * @return

     */

    private Criteria prepareList(Collection<?> uuids, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, String propertyName) {

        Criteria criteria = getSession().createCriteria(type);

        criteria.add(Restrictions.in(propertyName, uuids));

        if(pageSize != null) {

            criteria.setMaxResults(pageSize);

            if(pageNumber != null) {

                criteria.setFirstResult(pageNumber * pageSize);

            } else {

                criteria.setFirstResult(0);

            }

        }

        if(orderHints == null) {

            orderHints = OrderHint.defaultOrderHintsFor(type);

        }

        addOrder(criteria, orderHints);

        return criteria;

    }

    /**

     *

     * NOTE: We can't reuse {@link #list(Class, String, Object, MatchMode, Integer, Integer, List, List)

     * here due to different default behavior of the <code>matchmode</code> parameter.

     *

     * @param clazz

     * @param param

     * @param queryString

     * @param matchmode

     * @param criterion

     * @param pageSize

     * @param pageNumber

     * @param orderHints

     * @param propertyPaths

     * @return

     */

    protected List<T> findByParam(Class<? extends T> clazz, String param, String queryString, MatchMode matchmode, List<Criterion> criterion, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {

        Criteria criteria = criterionForType(clazz);

        if (queryString != null) {

            if(matchmode == null) {

                criteria.add(Restrictions.ilike(param, queryString));

            } else if(matchmode == MatchMode.BEGINNING) {

                criteria.add(Restrictions.ilike(param, queryString, org.hibernate.criterion.MatchMode.START));

            } else if(matchmode == MatchMode.END) {

                criteria.add(Restrictions.ilike(param, queryString, org.hibernate.criterion.MatchMode.END));

            } else if(matchmode == MatchMode.EXACT) {

                criteria.add(Restrictions.ilike(param, queryString, org.hibernate.criterion.MatchMode.EXACT));

            } else {

                criteria.add(Restrictions.ilike(param, queryString, org.hibernate.criterion.MatchMode.ANYWHERE));

            }

        }

        addCriteria(criteria, criterion);

        if(pageSize != null) {

            criteria.setMaxResults(pageSize);

            if(pageNumber != null) {

                criteria.setFirstResult(pageNumber * pageSize);

            } else {

                criteria.setFirstResult(0);

            }

        }

        addOrder(criteria, orderHints);

        @SuppressWarnings("unchecked")

		List<T> result = criteria.list();

        defaultBeanInitializer.initializeAll(result, propertyPaths);

        return result;

    }

    /**

     * @param clazz

     * @return

     */

    private Criteria criterionForType(Class<? extends T> clazz) {

        Criteria criteria;

        if(clazz == null) {

            criteria = getSession().createCriteria(type);

        } else {

            criteria = getSession().createCriteria(clazz);

        }

        return criteria;

    }

    @Override

    public T load(UUID uuid) {

        T bean = findByUuid(uuid);

        if(bean == null){

            return null;

        }

        defaultBeanInitializer.load(bean);

        return bean;

    }

    @Override

    public T load(int id, List<String> propertyPaths){

        T bean = findById(id);

        if(bean == null){

            return bean;

        }

        defaultBeanInitializer.initialize(bean, propertyPaths);

        return bean;

    }

    @Override

    public T load(UUID uuid, List<String> propertyPaths){

        T bean = findByUuid(uuid);

        if(bean == null){

            return bean;

        }

        defaultBeanInitializer.initialize(bean, propertyPaths);

        return bean;

    }

    @Override

    public Boolean exists(UUID uuid) {

        if (findByUuid(uuid)==null){

            return false;

        }

        return true;

    }

    @Override

    public int count() {

        return count(type);

    }

    @Override

    public int count(Class<? extends T> clazz) {

        Session session = getSession();

        Criteria criteria = null;

        if(clazz == null) {

            criteria = session.createCriteria(type);

        } else {

            criteria = session.createCriteria(clazz);

        }

        criteria.setProjection(Projections.projectionList().add(Projections.rowCount()));

        //since hibernate 4 (or so) uniqueResult returns Long, not Integer, therefore needs

        //to be casted. Think about returning long rather then int!

        return ((Number) criteria.uniqueResult()).intValue();

    }

    @Override

    public List<T> list(Integer limit, Integer start) {

        return list(limit, start, null);

    }

    @Override

    public List<Object[]> group(Class<? extends T> clazz,Integer limit, Integer start, List<Grouping> groups, List<String> propertyPaths) {

        Criteria criteria = null;

        criteria = criterionForType(clazz);

        addGroups(criteria,groups);

        if(limit != null) {

            criteria.setFirstResult(start);

            criteria.setMaxResults(limit);

        }

        @SuppressWarnings("unchecked")

		List<Object[]> result = criteria.list();

        if(propertyPaths != null && !propertyPaths.isEmpty()) {

          for(Object[] objects : result) {

            defaultBeanInitializer.initialize(objects[0], propertyPaths);

          }

        }

        return result;

    }

    protected void countGroups(DetachedCriteria criteria,List<Grouping> groups) {

        if(groups != null){

            Map<String,String> aliases = new HashMap<String,String>();

            for(Grouping grouping : groups) {

                if(grouping.getAssociatedObj() != null) {

                    String alias = null;

                    if((alias = aliases.get(grouping.getAssociatedObj())) == null) {

                        alias = grouping.getAssociatedObjectAlias();

                        aliases.put(grouping.getAssociatedObj(), alias);

                        criteria.createAlias(grouping.getAssociatedObj(),alias);

                    }

                }

            }

            ProjectionList projectionList = Projections.projectionList();

            for(Grouping grouping : groups) {

                grouping.addProjection(projectionList);

            }

            criteria.setProjection(projectionList);

        }

    }

    protected void addGroups(Criteria criteria,List<Grouping> groups) {

        if(groups != null){

            Map<String,String> aliases = new HashMap<String,String>();

            for(Grouping grouping : groups) {

                if(grouping.getAssociatedObj() != null) {

                    String alias = null;