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.EnumSet;

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.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

import org.hibernate.Criteria;

import org.hibernate.FlushMode;

import org.hibernate.HibernateException;

import org.hibernate.LockOptions;

import org.hibernate.NonUniqueObjectException;

import org.hibernate.Session;

import org.hibernate.criterion.Criterion;

import org.hibernate.criterion.DetachedCriteria;

import org.hibernate.criterion.Disjunction;

import org.hibernate.criterion.Example;

import org.hibernate.criterion.Example.PropertySelector;

import org.hibernate.criterion.LogicalExpression;

import org.hibernate.criterion.Order;

import org.hibernate.criterion.ProjectionList;

import org.hibernate.criterion.Projections;

import org.hibernate.criterion.Restrictions;

import org.hibernate.criterion.Subqueries;

import org.hibernate.envers.AuditReader;

import org.hibernate.envers.AuditReaderFactory;

import org.hibernate.envers.query.AuditQuery;

import org.hibernate.metadata.ClassMetadata;

import org.hibernate.sql.JoinType;

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.util.ReflectionUtils;

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

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

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

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

import eu.etaxonomy.cdm.model.view.AuditEvent;

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

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

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

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;

/**

 * Hibernate implementation for {@link ICdmEntityDao}.

 */

public abstract class CdmEntityDaoBase<T extends CdmBase>

        extends DaoBase

        implements ICdmEntityDao<T> {

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

    protected int flushAfterNo = 1000; // large numbers may cause synchronisation errors

                                        // when commiting the session

    protected Class<T> type;

    @Autowired

    // @Qualifier("defaultBeanInitializer")

    protected IBeanInitializer defaultBeanInitializer;

    public void setDefaultBeanInitializer(IBeanInitializer defaultBeanInitializer) {

        this.defaultBeanInitializer = defaultBeanInitializer;

    }

    @Autowired

    private ReferringObjectMetadataFactory referringObjectMetadataFactory;

    protected static final EnumSet<Operator> LEFTOUTER_OPS = EnumSet.of(Operator.AND_NOT, Operator.OR, Operator.OR_NOT);

    public CdmEntityDaoBase(Class<T> type) {

        this.type = type;

        assert type != null;

        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<? extends 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<? extends 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 <S extends T> S save(S 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 {

        return this.findByUuid(uuid, INCLUDE_UNPUBLISHED);

    }

    protected T findByUuid(UUID uuid, boolean includeUnpublished) throws DataAccessException {

        Session session = getSession();

        Criteria crit = session.createCriteria(type);

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

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

        if (IPublishable.class.isAssignableFrom(type) && !includeUnpublished) {

            crit.add(Restrictions.eq("publish", Boolean.TRUE));

        }

        @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.getHibernateFlushMode();

        try {

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

            // when before performing the query

            session.setHibernateFlushMode(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.setHibernateFlushMode(currentFlushMode);

            }

        }

    }

    @Override

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

        if (ids.isEmpty()) {

            return new ArrayList<>(0);

        }

        Criteria criteria = prepareList(null, ids, null, null, orderHints, "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(null, uuids, pageSize, pageNumber, orderHints, "uuid");

        @SuppressWarnings("unchecked")

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

        defaultBeanInitializer.initializeAll(result, propertyPaths);

        return result;

    }

    @Override

    public <S extends T> List<S> list(Class<S> clazz, 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(clazz, uuids, pageSize, pageNumber, orderHints, "uuid");

        @SuppressWarnings("unchecked")

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

        defaultBeanInitializer.initializeAll(result, propertyPaths);

        return result;

    }

    @Override

    public <S extends T> List<S> list(Class<S> type, List<Restriction<?>> restrictions, Integer limit, Integer start,

            List<OrderHint> orderHints, List<String> propertyPaths) {

        Criteria criteria = createCriteria(type, restrictions, false);

        addLimitAndStart(criteria, limit, start);

        addOrder(criteria, orderHints);

        @SuppressWarnings("unchecked")

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

        defaultBeanInitializer.initializeAll(result, propertyPaths);

        return result;

    }

    /**

     * @param restrictions

     * @param criteria

     */

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

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

            return ;

        }

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

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

        for(Restriction<?> restriction : restrictions){

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

            JoinType jointype = LEFTOUTER_OPS.contains(restriction.getOperator()) ? JoinType.LEFT_OUTER_JOIN : JoinType.INNER_JOIN;

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

                // ---

                String propertyPath = restriction.getPropertyName();

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

                String propertyName;

                if(props.length == 1){

                    // direct property of the base type of the criteria

                    propertyName = propertyPath;

                } else {

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

                    String aĺiasKey = jointype.name() + "_";

                    String aliasedProperty = null;

                    String alias = "";

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

                        aĺiasKey = aĺiasKey + (aĺiasKey.isEmpty() ? "" : ".") + props[p];

                        aliasedProperty = alias + (alias.isEmpty() ? "" : ".") + props[p];

                        if(!aliases.containsKey(aliasedProperty)){

                            alias = alias + (alias.isEmpty() ? "" : "_" ) + props[p];

                            aliases.put(aĺiasKey, alias);

                            criteria.createAlias(aliasedProperty, alias, jointype);

                            if(logger.isDebugEnabled()){

                                logger.debug("addRestrictions() alias created with aliasKey " + aĺiasKey + " => " + aliasedProperty + " as " + alias);

                            }

                        }

                    }

                    propertyName = alias + "." + props[props.length -1];

                }

                // ---

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

                int i = 0;

                for(Object v : values){

                    Criterion criterion = createRestriction(propertyName, v, restriction.getMatchMode());

                    if(restriction.isNot()){

                        if(props.length > 1){

                            criterion = Restrictions.or(Restrictions.not(criterion), Restrictions.isNull(propertyName));

                        } else {

                            criterion = Restrictions.not(criterion);

                        }

                    }

                    predicates[i++] = criterion;

                    if(logger.isDebugEnabled()){

                        logger.debug("addRestrictions() predicate with " + propertyName + " " + (restriction.getMatchMode() == null ? "=" : restriction.getMatchMode().name()) + " " + v.toString());

                    }

                }

                if(restriction.getOperator() == Operator.AND_NOT){

                    perProperty.add(new CriterionWithOperator(restriction.getOperator(), Restrictions.and(predicates)));

                } else {

                    perProperty.add(new CriterionWithOperator(restriction.getOperator(), Restrictions.or(predicates)));

                }

            } // check has values

        } // loop over restrictions

        Restriction.Operator firstOperator = null;

        if(!perProperty.isEmpty()){

            LogicalExpression logicalExpression = null;

            for(CriterionWithOperator cwo : perProperty){

                if(logicalExpression == null){

                    firstOperator = cwo.operator;

                    logicalExpression = Restrictions.and(Restrictions.sqlRestriction("1=1"), cwo.criterion);

                } else {

                    switch(cwo.operator){

                        case AND:

                        case AND_NOT:

                            logicalExpression = Restrictions.and(logicalExpression, cwo.criterion);

                            break;

                        case OR:

                        case OR_NOT:

                            logicalExpression = Restrictions.or(logicalExpression, cwo.criterion);

                            break;

                        default:

                            throw new RuntimeException("Unsupported Operator");

                    }

                }

            }

            criteria.add(logicalExpression);

//            if(firstOperator == Operator.OR){

//                // OR

//            } else {

//                // AND

//                criteria.add(Restrictions.and(queryStringCriterion, logicalExpression));

//            }

        }

        if(logger.isDebugEnabled()){

            logger.debug("addRestrictions() final criteria: " + criteria.toString());

        }

    }

    /**

     * @param propertyName

     * @param value

     * @param matchMode

     *            is only applied if the <code>value</code> is a

     *            <code>String</code> object

     * @param criteria

     * @return

     */

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

        Criterion restriction;

        if (value == null) {

            if (logger.isDebugEnabled()) {

                logger.debug("createRestriction() " + propertyName + " is null ");

            }

            restriction = Restrictions.isNull(propertyName);

        } else if (matchMode == null || !(value instanceof String)) {

            if (logger.isDebugEnabled()) {

                logger.debug("createRestriction() " + propertyName + " = " + value.toString());

            }

            restriction = Restrictions.eq(propertyName, value);

        } else {

            String queryString = (String) value;

            if (logger.isDebugEnabled()) {

                logger.debug("createRestriction() " + propertyName + " " + matchMode.getMatchOperator() + " "

                        + matchMode.queryStringFrom(queryString));

            }

            switch(matchMode){

            case BEGINNING:

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

                break;

            case END:

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

                break;

            case LIKE:

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

                break;

            case EXACT:

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

                break;

            case ANYWHERE:

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

                break;

            default:

                throw new RuntimeException("Unknown MatchMode: " + matchMode.name());

            }

        }

        return restriction;

    }

    /**

     * {@inheritDoc}

     */

    @Override

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

        Criteria criteria = createCriteria(type, restrictions, false);

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

        return (Long) criteria.uniqueResult();

    }

    /**

     * @param uuids

     * @param pageSize

     * @param pageNumber

     * @param orderHints

     * @param propertyName

     * @return

     */

    private Criteria prepareList(Class<? extends T> clazz, Collection<?> uuids, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints,

            String propertyName) {

        if (clazz == null){

            clazz = type;

        }

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

        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;

    }

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

        return  getSession().createCriteria(entityType(clazz));

    }

    protected Class<? extends T> entityType(Class<? extends T> clazz){

        if (clazz != null) {

            return clazz;

        } else {

            return type;

        }

    }

    @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 loadWithoutInitializing(int id){

        return this.getSession().load(type, id);

    }

    @Override

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

        return this.load(uuid, INCLUDE_UNPUBLISHED, propertyPaths);

    }

    protected T load(UUID uuid, boolean includeUnpublished, List<String> propertyPaths) {

        T bean = findByUuid(uuid, includeUnpublished);