EDIT

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

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

    private IDefinedTermDao termDao;

    public void setTermDao(IDefinedTermDao termDao) {

        this.termDao = termDao;

        EditGeoServiceUtilities.setTermDao(termDao);

    }

        Set<Feature> distributionFeature = new HashSet<Feature>();

        Set<Distribution> result = new HashSet<Distribution>();

        List<TaxonDescription> taxonDescriptions = new ArrayList<TaxonDescription>();

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

    private static IDefinedTermDao termDao;

    /**

     * @param termDao

     */

    public static void setTermDao(IDefinedTermDao termDao) {

        EditGeoServiceUtilities.termDao= termDao;

    }

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

    @SpringBeanByType

    private IDefinedTermDao termDao;

        EditGeoServiceUtilities.setTermDao(termDao);

    public void testGetWebServiceUrlCountry() throws MalformedURLException, IOException {

        Set<Distribution> distributions = new HashSet<Distribution>();

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

/**

* 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.common;

import java.net.URI;

import java.util.Collection;

import java.util.Enumeration;

import java.util.List;

import java.util.Locale;

import java.util.Set;

import java.util.UUID;

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

import eu.etaxonomy.cdm.model.location.Country;

import eu.etaxonomy.cdm.model.location.NamedArea;

import eu.etaxonomy.cdm.model.location.NamedAreaLevel;

import eu.etaxonomy.cdm.model.location.NamedAreaType;

import eu.etaxonomy.cdm.model.media.Media;

import eu.etaxonomy.cdm.model.term.DefinedTermBase;

import eu.etaxonomy.cdm.model.term.TermType;

import eu.etaxonomy.cdm.model.term.TermVocabulary;

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

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

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

public interface IDefinedTermDao extends IIdentifiableDao<DefinedTermBase>, ITitledDao<DefinedTermBase>{

	/**

	 * @param iso639 a two or three letter language code according to iso639-1 or iso639-2

	 * @return the Language or null

	 */

	//TODO refactor typo:

	public Language getLanguageByIso(String iso639);

	public List<Language> getLanguagesByIso(List<String> iso639List);

	public List<Language> getLanguagesByLocale(Enumeration<Locale> locales);

	 /**

     * Returns the country with the isoCode iso639, works only with string length 2 or 3

     *

     * @param iso639 the isoCode of the searched country

     *

     * @return country with isoCode iso639

     */

	public Country getCountryByIso(String iso639);

	public <TYPE extends DefinedTermBase> List<TYPE> getDefinedTermByRepresentationText(String text, Class<TYPE> clazz );

	public <TYPE extends DefinedTermBase> List<TYPE> getDefinedTermByRepresentationText(String text, Class<TYPE> clazz, Integer pageSize,Integer  pageNumber);

	public long countDefinedTermByRepresentationText(String text, Class<? extends DefinedTermBase> clazz);

	public <TYPE extends DefinedTermBase> List<TYPE> getDefinedTermByRepresentationAbbrev(String text, Class<TYPE> clazz, Integer pageSize,Integer  pageNumber);

	public long countDefinedTermByRepresentationAbbrev(String text, Class<? extends DefinedTermBase> clazz);

    /**

     * Returns a List of Media that represent a given DefinedTerm instance

     *

	 * @param definedTerm the definedTerm represented by these media

	 * @param pageSize The maximum number of media returned (can be null for all related media)

	 * @param pageNumber The offset (in pageSize chunks) from the start of the result set (0 - based)

     * @return a List of media instances

     */

	public List<Media> getMedia(DefinedTermBase definedTerm, Integer pageSize, Integer pageNumber);

	/**

	 * Returns a count of the Media that represent a given

	 * DefinedTermBase instance

	 *

	 * @param definedTerm the definedTerm represented by these media

	 * @return a count of Media entities

	 */

	public long countMedia(DefinedTermBase definedTerm);

	/**

	 * Returns a List of NamedArea instances (optionally filtered by type or level)

	 *

	 * @param level restrict the result set to named areas of a certain level (can be null)

	 * @param type restrict the result set to named areas of a certain type (can be null)

	 * @param pageSize The maximum number of namedAreas returned (can be null for all named areas)

	 * @param pageNumber The offset (in pageSize chunks) from the start of the result set (0 - based)

	 * @return a List of named areas

	 */

	public List<NamedArea> list(NamedAreaLevel level, NamedAreaType type, Integer pageSize, Integer pageNumber);

	/**

	 * @param level

	 * @param type

	 * @param pageSize

	 * @param pageNumber

	 * @param orderHints

	 * @param propertyPaths

	 * @return

	 */

	public List<NamedArea> list(NamedAreaLevel level, NamedAreaType type, Integer pageSize, Integer pageNumber,  List<OrderHint> orderHints, List<String> propertyPaths);

	/**

	 * Returns a count of NamedArea instances (optionally filtered by type or level)

	 *

	 * @param level restrict the result set to named areas of a certain level (can be null)

	 * @param type restrict the result set to named areas of a certain type (can be null)

	 * @return a count of named areas

	 */

	public long count(NamedAreaLevel level, NamedAreaType type);

	/**

	 * Return a list of terms which are specializations of a given definedTerm

	 *

	 * @param definedTerm The term which is a generalization of the terms returned

	 * @param pageSize The maximum number of terms returned (can be null for all specializations)

	 * @param pageNumber The offset (in pageSize chunks) from the start of the result set (0 - based)

	 * @return a List of DefinedTerms

	 */

	public <T extends DefinedTermBase> List<T> getGeneralizationOf(T definedTerm, Integer pageSize, Integer pageNumber);

	/**

	 * Return a count of terms which are specializations of a given definedTerm

	 *

	 * @param definedTerm The term which is a generalization of the terms returned

	 * @return a count of DefinedTerms

	 */

	public <T extends DefinedTermBase> long countGeneralizationOf(T definedTerm);

	/**

	 * Return a List of distinct terms which include the terms supplied

	 *

	 * @param definedTerms the set of terms which are part of the terms of interest

	 * @param pageSize The maximum number of terms returned (can be null for all terms)

	 * @param pageNumber The offset (in pageSize chunks) from the start of the result set (0 - based)

	 * @param propertyPaths properties to initialize - see {@link IBeanInitializer#initialize(Object, List)}

	 * @return a List of DefinedTerms

	 */

	public <T extends DefinedTermBase> List<T> getPartOf(Set<T> definedTerms, Integer pageSize, Integer pageNumber, List<String> propertyPaths);

	/**

	 * Return a count of distinct terms which include the terms supplied

	 *

	 * @param definedTerms the set of terms which are part of the terms of interest

	 * @return a count of DefinedTerms

	 */

	public <T extends DefinedTermBase> long countPartOf(Set<T> definedTerms);

	/**

	 * Return a List of terms which are part of the terms supplied

	 *

	 * @param definedTerms the collection of terms which include the terms of interest

	 * @param pageSize The maximum number of terms returned (can be null for all terms)

	 * @param pageNumber The offset (in pageSize chunks) from the start of the result set (0 - based)

	 * @param propertyPaths properties to initialize - see {@link IBeanInitializer#initialize(Object, List)}

	 * @return a List of DefinedTerms

	 */

	public <T extends DefinedTermBase> List<T> getIncludes(Collection<T> definedTerms, Integer pageSize, Integer pageNumber, List<String> propertyPaths);

	/**

	 * Return a count of terms which are part of the terms supplied

	 *

	 * @param definedTerms the set of terms which include the terms of interest

	 * @return a count of DefinedTerms

	 */

	public <T extends DefinedTermBase> long countIncludes(Collection<T> definedTerms);

	public DefinedTermBase findByUri(URI uri);

	/**

	 * Retrieves all {@link DefinedTermBase}s with the given {@link TermType}

	 * @param termType the term type to filter the terms

	 * @param limit

	 * @param start

	 * @param orderHints

	 * @param propertyPaths

	 * @return a list containing the terms

	 */

	public <T extends DefinedTermBase> List<T> listByTermType(TermType termType, Integer limit, Integer start, List<OrderHint> orderHints, List<String> propertyPaths);

	public <TERM extends DefinedTermBase> List<TERM> listByTermClass(Class<TERM> clazz, Integer limit, Integer start, List<OrderHint> orderHints, List<String> propertyPaths);

	/**

	 * Returns a term or a list of terms depending of the label/id used in its vocabulary.

	 * @param idInVoc

	 * @param vocUuid

	 * @param clazz

	 * @param pageSize

	 * @param pageNumber

	 * @return

	 */

	public <TERM extends DefinedTermBase> List<TERM> getDefinedTermByIdInVocabulary(String idInVoc, UUID vocUuid, Class<TERM> clazz, Integer pageSize, Integer pageNumber);

    /**

     * @param clazz

     * @param vocs

     * @param limit

     * @param pattern

     * @return

     */

    public List<NamedArea> getUuidAndTitleCache(List<TermVocabulary> vocs, Integer limit,

            String pattern);

    /**

     * Returns all terms that are included in the given parent term resp. a part of the given term.

     * @param parentTerm the parent term

     * @return a collection of included terms

     */

    public Collection<TermDto> getIncludesAsDto(TermDto parentTerm);

    /**

     * Returns all terms that the given term is a generalization of resp. that are a kind of the given term

     * @param parentTerm the parent term

     * @return a collection of included terms

     */

    public Collection<TermDto> getKindOfsAsDto(TermDto parentTerm);

    public Collection<TermDto> findByTitleAsDto(String title, TermType termType);

}

/**

* 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.common;

import eu.etaxonomy.cdm.model.term.OrderedTermBase;

import eu.etaxonomy.cdm.model.term.OrderedTermVocabulary;

/**

 * @author a.mueller

 *

 */

public interface IOrderedTermVocabularyDao extends ICdmEntityDao<OrderedTermVocabulary<OrderedTermBase<?>>> {

}

/**

* Copyright (C) 2009 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.common;

import java.util.List;

import eu.etaxonomy.cdm.model.term.Representation;

public interface IRepresentationDao extends ILanguageStringBaseDao<Representation> {

	public List<Representation> getAllRepresentations(Integer limit, Integer start);

}

/**

* 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.common;

import java.util.Collection;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.UUID;

import eu.etaxonomy.cdm.model.term.DefinedTermBase;

import eu.etaxonomy.cdm.model.term.TermType;

import eu.etaxonomy.cdm.model.term.TermVocabulary;

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

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

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

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

/**

 * @author a.mueller

 *

 */

public interface ITermVocabularyDao extends IIdentifiableDao<TermVocabulary> {

	/**

	 * Return a count of terms that belong to the termVocabulary supplied

	 *

	 * @param termVocabulary The term vocabulary which 'owns' the terms of interest

	 * @return a count of terms

	 */

	public long countTerms(TermVocabulary termVocabulary);

	/**

	 * Return a List of terms that belong to the termVocabulary supplied

	 *

	 * @param termVocabulary The term vocabulary which 'owns' the terms of interest

	 * @param pageSize The maximum number of terms returned (can be null for all terms)

	 * @param pageNumber The offset (in pageSize chunks) from the start of the result set (0 - based)

	 * @return a List of terms

	 */

	public <T extends DefinedTermBase> List<T> getTerms(TermVocabulary<T> termVocabulary, Integer pageSize, Integer pageNumber);

	public <T extends DefinedTermBase> TermVocabulary<T> findByUri(String termSourceUri, Class<T> clazz);

	/**

	 * Return a List of terms that belong to the termVocabulary supplied

	 *

	 * @param termVocabulary The term vocabulary which 'owns' the terms of interest

	 * @param pageSize The maximum number of terms returned (can be null for all terms)

	 * @param pageNumber The offset (in pageSize chunks) from the start of the result set (0 - based)

	 * @param orderHints

	 *            Supports path like <code>orderHints.propertyNames</code> which

	 *            include *-to-one properties like createdBy.username or

	 *            authorTeam.persistentTitleCache

	 * @param propertyPaths properties to be initialized

	 * @return a List of terms

	 */

	public <T extends DefinedTermBase> List<T> getTerms(TermVocabulary<T> vocabulary,Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths);

    /**

     * Return a List of vocabularies that belong to the term type supplied

     *

     * @param termType The term type corresponding to the vocabularies of interest

     * @param propertyPaths

     * @return a List of vocabularies

     */

    public <T extends DefinedTermBase> List<TermVocabulary<T>> findByTermType(TermType termType, List<String> propertyPaths);

	/**

     * Returns term vocabularies that contain terms of a certain {@link TermType} e.g. Feature, Modifier, State.

     *

     * @param <TERMTYPE>

     * @param termType the {@link TermType} of the terms in the vocabulary and of the vocabulary

     * @param includeSubtypes if <code>true</code> all subtypes will be included for computation of the result

     * @param limit The maximum number of vocabularies returned (can be null for all vocabularies)

     * @param start The offset from the start of the result set (0 - based, can be null - equivalent of starting at the beginning of the recordset)

     * @param orderHints

     *            Supports path like <code>orderHints.propertyNames</code> which

     *            include *-to-one properties like createdBy.username or

     *            authorTeam.persistentTitleCache

     * @param propertyPaths properties to be initialized

     * @return a list of term vocabularies

     */

	public List<TermVocabulary> listByTermType(TermType termType, boolean includeSubtypes, Integer limit, Integer start, List<OrderHint> orderHints, List<String> propertyPaths);

	/**

	 * Fills the response map with those term uuids which do exist in the requested map

	 * but not in the repository (missing terms). The map key is the vocabulary uuid in both cases.

	 * If parameter vocabularyRepsonse is not <code>null</code> the vocabularies will be fully loaded

	 * and returned within the map. The later is for using this method together with fast termloading.

	 * @param uuidsRequested

	 * @param uuidsRepsonse

	 * @param vocabularyResponse

	 */

	public void missingTermUuids(Map<UUID, Set<UUID>> uuidsRequested,

			Map<UUID, Set<UUID>> uuidsRepsonse,

			Map<UUID, TermVocabulary<?>> vocabularyResponse);

    /**

     * Loads all top level terms, i.e. terms that have no parent terms, for the given vocabulary

     * @param vocabularyUuid the id of the vocabulary

     * @return a collection of top level terms

     */

    public Collection<TermDto> getTopLevelTerms(UUID vocabularyUuid);

    /**

     * Returns term vocabularies that contain terms of a certain {@link TermType} e.g. Feature, Modifier, State.

     *

     * @param termType the {@link TermType} of the terms in the vocabulary and of the vocabulary

     * @return a list of term vocabularies

     */

    public List<TermVocabularyDto> findVocabularyDtoByTermType(TermType termType);

    /**

     *

     * Like {@link #getUuidAndTitleCache(Class, Integer, String)} but filtering

     * the results by {@link TermType} of the vocabularies.

     *

     *

     * @param clazz

     *            the (sub)class

     * @param termType

     *            the {@link TermType} of the vocabularies to be retrieved

     * @param limit

     *            max number of results

     * @param pattern

     *            search pattern

     * @return a list of {@link UuidAndTitleCache}

     *

     * @see #getUuidAndTitleCache(Class, Integer, String))

     */

    public <S extends TermVocabulary> List<UuidAndTitleCache<S>> getUuidAndTitleCache(Class<S> clazz, TermType termType,

            Integer limit, String pattern);

}

/**

* 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.net.URI;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Enumeration;

import java.util.Iterator;

import java.util.List;

import java.util.Locale;

import java.util.Set;

import java.util.UUID;

import org.apache.commons.lang.StringUtils;

import org.apache.log4j.Logger;

import org.hibernate.Criteria;

import org.hibernate.Query;

import org.hibernate.Session;

import org.hibernate.criterion.Criterion;

import org.hibernate.criterion.Projections;

import org.hibernate.criterion.Restrictions;

import org.hibernate.envers.query.AuditEntity;

import org.hibernate.envers.query.AuditQuery;

import org.springframework.stereotype.Repository;

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

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

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

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

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

import eu.etaxonomy.cdm.model.description.MeasurementUnit;

import eu.etaxonomy.cdm.model.description.PresenceAbsenceTerm;

import eu.etaxonomy.cdm.model.description.State;

import eu.etaxonomy.cdm.model.description.StatisticalMeasure;

import eu.etaxonomy.cdm.model.description.TextFormat;

import eu.etaxonomy.cdm.model.location.Country;

import eu.etaxonomy.cdm.model.location.NamedArea;

import eu.etaxonomy.cdm.model.location.NamedAreaLevel;

import eu.etaxonomy.cdm.model.location.NamedAreaType;

import eu.etaxonomy.cdm.model.location.ReferenceSystem;

import eu.etaxonomy.cdm.model.media.Media;

import eu.etaxonomy.cdm.model.media.RightsType;

import eu.etaxonomy.cdm.model.name.HybridRelationshipType;

import eu.etaxonomy.cdm.model.name.NameRelationshipType;

import eu.etaxonomy.cdm.model.name.NameTypeDesignationStatus;

import eu.etaxonomy.cdm.model.name.NomenclaturalStatusType;

import eu.etaxonomy.cdm.model.name.Rank;

import eu.etaxonomy.cdm.model.name.SpecimenTypeDesignationStatus;

import eu.etaxonomy.cdm.model.occurrence.DerivationEventType;

import eu.etaxonomy.cdm.model.taxon.SynonymType;

import eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType;

import eu.etaxonomy.cdm.model.term.DefinedTerm;

import eu.etaxonomy.cdm.model.term.DefinedTermBase;

import eu.etaxonomy.cdm.model.term.TermType;

import eu.etaxonomy.cdm.model.term.TermVocabulary;

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

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

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

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

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

/**

 * @author a.kohlbecker

 * @since 29.05.2008

 * @version 1.0

 */

@Repository

public class DefinedTermDaoImpl extends IdentifiableDaoBase<DefinedTermBase> implements IDefinedTermDao{

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

	public DefinedTermDaoImpl() {

		super(DefinedTermBase.class);

		indexedClasses = new Class[25];

		indexedClasses[0] = Rank.class;

		indexedClasses[1] = AnnotationType.class;

		indexedClasses[2] = ExtensionType.class;

		indexedClasses[3] = Language.class;

		indexedClasses[4] = MarkerType.class;

		indexedClasses[5] = MeasurementUnit.class;

		indexedClasses[6] = DefinedTerm.class;

		indexedClasses[7] = PresenceAbsenceTerm.class;

		indexedClasses[8] = State.class;

		indexedClasses[9] = StatisticalMeasure.class;

		indexedClasses[10] = TextFormat.class;

		indexedClasses[11] = DerivationEventType.class;

		indexedClasses[12] = NamedArea.class;

		indexedClasses[13] = NamedAreaLevel.class;

		indexedClasses[14] = NamedAreaType.class;

		indexedClasses[15] = ReferenceSystem.class;

		indexedClasses[16] = Country.class;

		indexedClasses[17] = RightsType.class;

		indexedClasses[18] = HybridRelationshipType.class;

		indexedClasses[19] = NameRelationshipType.class;

		indexedClasses[20] = NameTypeDesignationStatus.class;

		indexedClasses[21] = NomenclaturalStatusType.class;

		indexedClasses[22] = SpecimenTypeDesignationStatus.class;

		indexedClasses[23] = SynonymType.class;

		indexedClasses[24] = TaxonRelationshipType.class;

	}

	/**

	 * Searches by Label

	 * @see eu.etaxonomy.cdm.persistence.dao.common.ITitledDao#findByTitle(java.lang.String)

	 */

	@Override

    public List<DefinedTermBase> findByTitle(String queryString) {

		return findByTitle(queryString, null);

	}

	/**

	 * Searches by Label

	 * @see eu.etaxonomy.cdm.persistence.dao.common.ITitledDao#findByTitle(java.lang.String, eu.etaxonomy.cdm.model.common.CdmBase)

	 */

	@Override

    public List<DefinedTermBase> findByTitle(String queryString, CdmBase sessionObject) {

		checkNotInPriorView("DefinedTermDaoImpl.findByTitle(String queryString, CdmBase sessionObject)");

		Session session = getSession();

		if ( sessionObject != null ) {//attache the object to the session, TODO needed?

			session.update(sessionObject);

		}

		Query query = session.createQuery("select term from DefinedTermBase term join fetch term.representations representation where representation.label = :label");

		query.setParameter("label", queryString);

		return query.list();

	}

	@Override

    public List<DefinedTermBase> findByTitleAndClass(String queryString, Class<DefinedTermBase> clazz) {

		checkNotInPriorView("DefinedTermDaoImpl.findByTitleAndClass(String queryString, Class<DefinedTermBase> clazz)");

		Session session = getSession();

		Criteria crit = session.createCriteria(clazz);

		crit.add(Restrictions.ilike("persistentTitleCache", queryString));

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

		return results;

	}

	@Override

    public List<DefinedTermBase> findByTitle(String queryString, MatchMode matchMode, int page, int pagesize, List<Criterion> criteria) {

		//FIXME is query parametrised?

		checkNotInPriorView("DefinedTermDaoImpl.findByTitle(String queryString, ITitledDao.MATCH_MODE matchMode, int page, int pagesize, List<Criterion> criteria)");

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

		crit.add(Restrictions.ilike("titleCache", matchMode.queryStringFrom(queryString)));

		crit.setMaxResults(pagesize);

		int firstItem = (page - 1) * pagesize + 1;

		crit.setFirstResult(firstItem);

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

		return results;

	}

	@Override

    public Country getCountryByIso(String iso3166) {

		// If iso639 = "" query returns non-unique result. We prevent this here:

		if (StringUtils.isBlank(iso3166) || iso3166.length()<2 || iso3166.length()>3) { return null; }

		AuditEvent auditEvent = getAuditEventFromContext();

		if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {

		    Query query = getSession().createQuery("from Country where iso3166_A2 = :isoCode OR idInVocabulary = :isoCode");

		    query.setParameter("isoCode", iso3166);

		    return (Country) query.uniqueResult();

		} else {

			AuditQuery query = getAuditReader().createQuery().forEntitiesAtRevision(Country.class,auditEvent.getRevisionNumber());

			query.add(AuditEntity.property("iso3166_A2").eq(iso3166));

			query.add(AuditEntity.property("idInVocabulary").eq(iso3166));

			return (Country) query.getSingleResult();

		}

	}

	@Override

    public <T extends DefinedTermBase> List<T> getDefinedTermByRepresentationText(String text, Class<T> clazz ) {

		return getDefinedTermByRepresentationText(text,clazz,null,null);

	}

	@Override

    public <T extends DefinedTermBase> List<T> getDefinedTermByRepresentationText(String text, Class<T> clazz, Integer pageSize,Integer  pageNumber) {

		checkNotInPriorView("DefinedTermDaoImpl.getDefinedTermByRepresentationText(String text, Class<T> clazz, Integer pageSize,Integer  pageNumber)");

		Criteria criteria = getCriteria(clazz);

		criteria.createAlias("representations", "r").add(Restrictions.like("r.text", text));

		addPageSizeAndNumber(criteria, pageSize, pageNumber);

		@SuppressWarnings("unchecked")

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

		return result;

	}

	@Override

    public long countDefinedTermByRepresentationText(String text, Class<? extends DefinedTermBase> clazz) {

	    checkNotInPriorView("DefinedTermDaoImpl.countDefinedTermByRepresentationText(String text, Class<? extends DefinedTermBase> clazz)");

		Criteria criteria = getCriteria(clazz);

		criteria.createAlias("representations", "r").add(Restrictions.like("r.text", text));

		criteria.setProjection(Projections.rowCount());

		return (Long)criteria.uniqueResult();

	}

	@Override

	public <T extends DefinedTermBase> List<T> getDefinedTermByIdInVocabulary(String label, UUID vocUuid, Class<T> clazz, Integer pageSize, Integer pageNumber) {

		checkNotInPriorView("DefinedTermDaoImpl.getDefinedTermByIdInVocabulary(String label, UUID vocUuid, Class<T> clazz, Integer pageSize, Integer pageNumber)");

		Criteria criteria = getCriteria(clazz);

		criteria.createAlias("vocabulary", "voc")

		    .add(Restrictions.like("voc.uuid", vocUuid))

			.add(Restrictions.like("idInVocabulary", label, org.hibernate.criterion.MatchMode.EXACT));

		addPageSizeAndNumber(criteria, pageSize, pageNumber);

		@SuppressWarnings("unchecked")

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

		return result;

	}

    @Override

	public <T extends DefinedTermBase> List<T> getDefinedTermByRepresentationAbbrev(String text, Class<T> clazz, Integer pageSize,Integer  pageNumber) {

		checkNotInPriorView("DefinedTermDaoImpl.getDefinedTermByRepresentationAbbrev(String abbrev, Class<T> clazz, Integer pageSize,Integer  pageNumber)");

		Criteria criteria = getCriteria(clazz);

		criteria.createAlias("representations", "r").add(Restrictions.like("r.abbreviatedLabel", text));

		addPageSizeAndNumber(criteria, pageSize, pageNumber);

		@SuppressWarnings("unchecked")

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

		return result;

	}

	@Override

	public long countDefinedTermByRepresentationAbbrev(String text, Class<? extends DefinedTermBase> clazz) {

	    checkNotInPriorView("DefinedTermDaoImpl.countDefinedTermByRepresentationAbbrev(String abbrev, Class<? extends DefinedTermBase> clazz)");

		Criteria criteria = getCriteria(clazz);

		criteria.createAlias("representations", "r").add(Restrictions.like("r.abbreviatedLabel", text));

		criteria.setProjection(Projections.rowCount());

        return (Long)criteria.uniqueResult();

	}

	@Override

    public Language getLanguageByIso(String iso639) {

		if (iso639.length() < 2 || iso639.length() > 3) {

			logger.warn("Invalid length " + iso639.length() + " of ISO code. Length must be 2 or 3.");

			return null;

		}

		boolean isIso639_1 = iso639.length() == 2;

		String queryStr;

		if (isIso639_1){

			queryStr = "from Language where iso639_1 = :isoCode";

		}else{

			queryStr = "from Language where idInVocabulary = :isoCode and vocabulary.uuid = :vocUuid";

		}

		AuditEvent auditEvent = getAuditEventFromContext();

		if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {

		    Query query = getSession().createQuery(queryStr);

		    query.setParameter("isoCode", iso639);

		    if (! isIso639_1){

		    	query.setParameter("vocUuid", Language.uuidLanguageVocabulary);

			}

		    return (Language) query.uniqueResult();

		} else {

			AuditQuery query = getAuditReader().createQuery().forEntitiesAtRevision(Language.class,auditEvent.getRevisionNumber());

			if (isIso639_1){

				query.add(AuditEntity.property("iso639_1").eq(iso639));

			}else{

				query.add(AuditEntity.property("iso639_2").eq(iso639));

				query.add(AuditEntity.property("vocabulary.uuid").eq(Language.uuidLanguageVocabulary));

			}

			return (Language)query.getSingleResult();

		}

	}

	/**

	 *  FIXME this will result in a query per language - could you, given that iso codes

	 *  are unique, use from Language where iso639_1 in (:isoCode) or iso639_2 in (:isoCode)

	 */

	@Override

    public List<Language> getLanguagesByIso(List<String> iso639List) {

		List<Language> languages = new ArrayList<Language>(iso639List.size());

		for (String iso639 : iso639List) {

			languages.add(getLanguageByIso(iso639));

		}

		return languages;

	}

	@Override

    public List<Language> getLanguagesByLocale(Enumeration<Locale> locales) {

		List<Language> languages = new ArrayList<Language>();

		while(locales.hasMoreElements()) {

			Locale locale = locales.nextElement();

			languages.add(getLanguageByIso(locale.getLanguage()));

		}

		return languages;

	}

	@Override

    public long count(NamedAreaLevel level, NamedAreaType type) {

		AuditEvent auditEvent = getAuditEventFromContext();

		if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {

		    Criteria criteria = getCriteria(NamedArea.class);

		    if(level != null) {

			    criteria.add(Restrictions.eq("level",level));

		    }

		    if(type != null) {

			    criteria.add(Restrictions.eq("type", type));

		    }

		    criteria.setProjection(Projections.rowCount());

	        return (Long)criteria.uniqueResult();

		} else {

			AuditQuery query = makeAuditQuery(NamedArea.class, auditEvent);

			if(level != null) {

				query.add(AuditEntity.relatedId("level").eq(level.getId()));

		    }

		    if(type != null) {

		    	query.add(AuditEntity.relatedId("type").eq(type.getId()));

		    }

		    query.addProjection(AuditEntity.id().count());

		    return (Long)query.getSingleResult();

		}

	}

	@Override

    public long countMedia(DefinedTermBase definedTerm) {

		checkNotInPriorView("DefinedTermDaoImpl.countMedia(DefinedTermBase definedTerm)");

		Query query = getSession().createQuery("select count(media) from DefinedTermBase definedTerm join definedTerm.media media where definedTerm = :definedTerm");

	    query.setParameter("definedTerm", definedTerm);

		return (Long)query.uniqueResult();

	}

	@Override

    public List<Media> getMedia(DefinedTermBase definedTerm, Integer pageSize,	Integer pageNumber) {

		checkNotInPriorView("DefinedTermDaoImpl.getMedia(DefinedTermBase definedTerm, Integer pageSize,	Integer pageNumber)");

		Query query = getSession().createQuery("select media from DefinedTermBase definedTerm join definedTerm.media media where definedTerm = :definedTerm");

		query.setParameter("definedTerm", definedTerm);

		addPageSizeAndNumber(query, pageSize, pageNumber);

		@SuppressWarnings("unchecked")

        List<Media> result = query.list();

		return result;

	}

	@Override

    public List<NamedArea> list(NamedAreaLevel level, NamedAreaType type, Integer pageSize, Integer pageNumber) {

		AuditEvent auditEvent = getAuditEventFromContext();

		if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {

            Criteria criteria = getCriteria(NamedArea.class);

		    if(level != null) {

			    criteria.add(Restrictions.eq("level",level));

		    }

		    if(type != null) {

			    criteria.add(Restrictions.eq("type", type));

		    }

		    addPageSizeAndNumber(criteria, pageSize, pageNumber);

	        @SuppressWarnings("unchecked")

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

	        return result;

		} else {

            AuditQuery query = makeAuditQuery(NamedArea.class, auditEvent);

			if(level != null) {

				query.add(AuditEntity.relatedId("level").eq(level.getId()));

		    }

		    if(type != null) {

		    	query.add(AuditEntity.relatedId("type").eq(type.getId()));

		    }

		    @SuppressWarnings("unchecked")

            List<NamedArea> result = query.getResultList();

		    return result;

		}

	}

	@Override

    public List<NamedArea> list(NamedAreaLevel level, NamedAreaType type, Integer pageSize, Integer pageNumber,

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

	    List<NamedArea> result;

		AuditEvent auditEvent = getAuditEventFromContext();

		if (auditEvent.equals(AuditEvent.CURRENT_VIEW)) {

			Criteria criteria = getCriteria(NamedArea.class);

			if (level != null) {

				criteria.add(Restrictions.eq("level", level));

			}

			if (type != null) {

				criteria.add(Restrictions.eq("type", type));

			}

			addOrder(criteria,orderHints);

			addPageSizeAndNumber(criteria, pageSize, pageNumber);

			result = criteria.list();

		} else {

			AuditQuery query = getAuditReader().createQuery().forEntitiesAtRevision(NamedArea.class,

				auditEvent.getRevisionNumber());

			if (level != null) {

				query.add(AuditEntity.relatedId("level").eq(level.getId()));

			}

			if (type != null) {

				query.add(AuditEntity.relatedId("type").eq(type.getId()));

			}

			result = query.getResultList();

		}

		defaultBeanInitializer.initializeAll(result, propertyPaths);

		return result;

	}

	@Override

    public <T extends DefinedTermBase> long countGeneralizationOf(T kindOf) {

		AuditEvent auditEvent = getAuditEventFromContext();

		if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {

		    Query query = getSession().createQuery("select count(term) from DefinedTermBase term where term.kindOf = :kindOf");

		    query.setParameter("kindOf", kindOf);

		    return (Long)query.uniqueResult();

		} else {

            AuditQuery query = makeAuditQuery(DefinedTermBase.class,auditEvent);

			query.add(AuditEntity.relatedId("kindOf").eq(kindOf.getId()));

		    query.addProjection(AuditEntity.id().count());

		    return (Long)query.getSingleResult();

		}

	}

	@Override

    public <T extends DefinedTermBase> long countIncludes(Collection<T> partOf) {

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

			return 0;

		}

		AuditEvent auditEvent = getAuditEventFromContext();

		if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {

    		Query query = getSession().createQuery("select count(term) from DefinedTermBase term where term.partOf in (:partOf)");

	    	query.setParameterList("partOf", partOf);

		    return (Long)query.uniqueResult();

		} else {

			long count = 0;

			for(T t : partOf) {

				AuditQuery query = makeAuditQuery(DefinedTermBase.class, auditEvent);

				query.add(AuditEntity.relatedId("partOf").eq(t.getId()));

			    query.addProjection(AuditEntity.id().count());

			    count += (Long)query.getSingleResult();

			}

			return count;

		}

	}

	@Override

    public <T extends DefinedTermBase> List<T> getGeneralizationOf(T kindOf, Integer pageSize, Integer pageNumber) {

		AuditEvent auditEvent = getAuditEventFromContext();

		if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {

		    Query query = getSession().createQuery("select term from DefinedTermBase term where term.kindOf = :kindOf");

		    query.setParameter("kindOf", kindOf);

		    addPageSizeAndNumber(query, pageSize, pageNumber);

		    @SuppressWarnings("unchecked")

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

		    return result;

		} else {

			 AuditQuery query = makeAuditQuery(DefinedTermBase.class, auditEvent);

			 query.add(AuditEntity.relatedId("kindOf").eq(kindOf.getId()));

			 addPageSizeAndNumber(query, pageSize, pageNumber);

             @SuppressWarnings("unchecked")

             List<T> result = query.getResultList();

             return result;

		}

	}

	@Override

    public <T extends DefinedTermBase> List<T> getIncludes(Collection<T> partOf,	Integer pageSize, Integer pageNumber, List<String> propertyPaths) {

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

			return new ArrayList<>();

		}

		AuditEvent auditEvent = getAuditEventFromContext();

		if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {

    		Query query = getSession().createQuery("select term from DefinedTermBase term where term.partOf in (:partOf)");

    		query.setParameterList("partOf", partOf);

    		addPageSizeAndNumber(query, pageSize, pageNumber);

		    @SuppressWarnings("unchecked")

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

		    defaultBeanInitializer.initializeAll(results, propertyPaths);

		    return results;

		} else {

			List<T> result = new ArrayList<T>();

			for(T t : partOf) {

				AuditQuery query = makeAuditQuery(DefinedTermBase.class, auditEvent);

				query.add(AuditEntity.relatedId("partOf").eq(t.getId()));

				addPageSizeAndNumber(query, pageSize, pageNumber);

			    result.addAll(query.getResultList());

			}

			defaultBeanInitializer.initializeAll(result, propertyPaths);

			return result;

		}

	}

	@Override

    public <T extends DefinedTermBase> long countPartOf(Set<T> definedTerms) {

		checkNotInPriorView("DefinedTermDaoImpl.countPartOf(Set<T> definedTerms)");

		Query query = getSession().createQuery("select count(distinct definedTerm) from DefinedTermBase definedTerm join definedTerm.includes included where included in (:definedTerms)");

		query.setParameterList("definedTerms", definedTerms);

		return (Long)query.uniqueResult();

	}

	@Override

    public <T extends DefinedTermBase> List<T> getPartOf(Set<T> definedTerms, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {

		checkNotInPriorView("DefinedTermDaoImpl.getPartOf(Set<T> definedTerms, Integer pageSize, Integer pageNumber)");

		Query query = getSession().createQuery("select distinct definedTerm from DefinedTermBase definedTerm join definedTerm.includes included where included in (:definedTerms)");

		query.setParameterList("definedTerms", definedTerms);

		addPageSizeAndNumber(query, pageSize, pageNumber);

		@SuppressWarnings("unchecked")

        List<T> r = query.list();

		/**

		 * For some weird reason, hibernate returns proxies (extending the superclass), not the actual class on this,

		 * despite querying the damn database and returning the discriminator along with the rest of the object properties!

		 *

		 * Probably a bug in hibernate, but we'll manually deproxy for now since the objects are initialized anyway, the

		 * performance implications are small (we're swapping one array of references for another, not hitting the db or

		 * cache).

		 */

		List<T> results = new ArrayList<>();

		if(!definedTerms.isEmpty()) {

		    for(T t : r) {

		        T deproxied = CdmBase.deproxy(t);

                results.add(deproxied);

		    }

		    defaultBeanInitializer.initializeAll(results, propertyPaths);

		}

		return results;

	}

	@Override

    public DefinedTermBase findByUri(URI uri) {

		AuditEvent auditEvent = getAuditEventFromContext();

		if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {

		    Query query = getSession().createQuery("select term from DefinedTermBase term where term.uri = :uri");

		    query.setParameter("uri", uri);

		    return (DefinedTermBase<?>)query.uniqueResult();

		} else {

			AuditQuery query = makeAuditQuery(DefinedTermBase.class, auditEvent);

			query.add(AuditEntity.property("uri").eq(uri));

		    return (DefinedTermBase<?>)query.getSingleResult();

		}

	}

	@Override

	public <T extends DefinedTermBase> List<T> listByTermType(TermType termType, Integer limit, Integer start,

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

	    Query query = getSession().createQuery("SELECT term FROM DefinedTermBase term WHERE term.termType = :termType");

	    query.setParameter("termType", termType);

	    @SuppressWarnings("unchecked")

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

	    defaultBeanInitializer.initializeAll(result, propertyPaths);

        return result;

	}

	@Override

    public <TERM extends DefinedTermBase> List<TERM> listByTermClass(Class<TERM> clazz, Integer limit, Integer start, List<OrderHint> orderHints, List<String> propertyPaths) {

//		checkNotInPriorView("DefinedTermDaoImpl.listByTermClass(Class<TERM> clazz, Integer limit, Integer start, List<OrderHint> orderHints, List<String> propertyPaths)");

		Query query = getSession().createQuery("FROM " + clazz.getSimpleName());

	    @SuppressWarnings("unchecked")

        List<TERM> result = query.list();

	    defaultBeanInitializer.initializeAll(result, propertyPaths);

	    return result;

	}

    @Override

    public <S extends DefinedTermBase> List<S> list(Class<S> type, Integer limit, Integer start,

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

        return deduplicateResult(super.list(type, limit, start, orderHints, propertyPath));

    }

    /**

     * Workaround for http://dev.e-taxonomy.eu/trac/ticket/5871 and #5945

     * Terms with multiple representations return identical duplicates

     * due to eager representation loading. We expect these duplicates to appear

     * in line wo we only compare one term with its predecessor. If it already

     * exists we remove it from the result.

     * @param orginals

     * @return

     */

    private <S extends DefinedTermBase<?>> List<S> deduplicateResult(List<S> orginals) {

        List<S> result = new ArrayList<>();

        Iterator<S> it = orginals.iterator();

        S last = null;

        while (it.hasNext()){

            S a = it.next();

            if (a != last){

                if (!result.contains(a)){

                    result.add(a);

                }

            }

            last = a;

        }

        return result;

    }

    @Override

    public List<NamedArea> getUuidAndTitleCache(List<TermVocabulary> vocs, Integer limit, String pattern){

        Session session = getSession();

        Query query = null;

        if (pattern != null){

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

                query = session.createQuery("from NamedArea where titleCache like :pattern and vocabulary in :vocs");

                query.setParameterList("vocs", vocs);

            }else{

                query = session.createQuery("from NamedArea where titleCache like :pattern ");

            }

            pattern = pattern.replace("*", "%");

            pattern = pattern.replace("?", "_");

            pattern = pattern + "%";

            query.setParameter("pattern", pattern);

        } else {

            query = session.createQuery("FROM NamedArea WHERE vocabulary IN :vocs");

            query.setParameterList("vocs", vocs);

        }

        if (limit != null){

           query.setMaxResults(limit);

        }

        @SuppressWarnings("unchecked")

        List<NamedArea> result = query.list();

        return result;

    }

    @Override

    public Collection<TermDto> getIncludesAsDto(

            TermDto parentTerm) {

        String queryString = TermDto.getTermDtoSelect()

                + "where a.partOf.uuid = :parentUuid";

        Query query =  getSession().createQuery(queryString);

        query.setParameter("parentUuid", parentTerm.getUuid());

        @SuppressWarnings("unchecked")

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

        List<TermDto> list = TermDto.termDtoListFrom(result);

        return list;

    }

    @Override

    public Collection<TermDto> getKindOfsAsDto(

            TermDto parentTerm) {

        String queryString = TermDto.getTermDtoSelect()

                + "where a.kindOf.uuid = :parentUuid";

        Query query =  getSession().createQuery(queryString);

        query.setParameter("parentUuid", parentTerm.getUuid());

        @SuppressWarnings("unchecked")

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

        List<TermDto> list = TermDto.termDtoListFrom(result);

        return list;

    }

    @Override

    public Collection<TermDto> findByTitleAsDto(String title, TermType termType) {

        String queryString = TermDto.getTermDtoSelect()

                + " where a.titleCache like :title "

                + (termType!=null?" and a.termType = :termType ":"");

        Query query =  getSession().createQuery(queryString);

        query.setParameter("title", "%"+title+"%");

        if(termType!=null){

            query.setParameter("termType", termType);

        }

        @SuppressWarnings("unchecked")

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

        List<TermDto> list = TermDto.termDtoListFrom(result);

        return list;

    }

}

/**

* 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 org.springframework.stereotype.Repository;

import eu.etaxonomy.cdm.model.term.OrderedTermBase;

import eu.etaxonomy.cdm.model.term.OrderedTermVocabulary;

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

/**

 * @author a.mueller

 * TODO this dao is maybe only a work around for an ClassCastException error thrown when

 * OrderedTermVocabulary<Rank> rankVocabulary = (OrderedTermVocabulary)orderedVocabularyDao.findByUuid(rankUuid);

 * is called in NameServiceImpl.getRankVocabulary().

 * If data exist in the database, it returns a TermVocabulary$CGLIB class created by hibernate

 */

@Repository

public class OrderedTermVocabularyDaoImpl extends CdmEntityDaoBase<OrderedTermVocabulary<OrderedTermBase<?>>> implements

		IOrderedTermVocabularyDao {

	/**

	 * @param type

	 */

	public OrderedTermVocabularyDaoImpl() {

		super((Class)OrderedTermVocabulary.class);

	}

}

/**

* Copyright (C) 2008 EDIT

* European Distributed Institute of Taxonomy 

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

*/

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

import java.util.List;

import org.apache.log4j.Logger;

import org.hibernate.Criteria;

import org.springframework.stereotype.Repository;

import eu.etaxonomy.cdm.model.term.Representation;

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

/**

 * @author a.babadshanjan

 * @since 10.09.2008

 */

@Repository

public class RepresentationDaoImpl 

extends LanguageStringBaseDaoImpl<Representation> implements IRepresentationDao {

	@SuppressWarnings("unused")

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

	public RepresentationDaoImpl() {

		super(Representation.class); 

	}

	public List<Representation> getAllRepresentations(Integer limit, Integer start) {

		Criteria crit = getSession().createCriteria(Representation.class);

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

		return results;

	}

}

/**

* 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.util.ArrayList;

import java.util.Collection;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.UUID;

import org.hibernate.Criteria;

import org.hibernate.Query;

import org.hibernate.Session;

import org.hibernate.criterion.Restrictions;

import org.hibernate.envers.query.AuditEntity;

import org.hibernate.envers.query.AuditQuery;

import org.springframework.stereotype.Repository;

import eu.etaxonomy.cdm.model.term.DefinedTermBase;

import eu.etaxonomy.cdm.model.term.OrderedTermVocabulary;

import eu.etaxonomy.cdm.model.term.Representation;

import eu.etaxonomy.cdm.model.term.TermType;

import eu.etaxonomy.cdm.model.term.TermVocabulary;

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

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

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

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

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

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

/**

 * @author a.mueller

 *

 */

@Repository

public class TermVocabularyDaoImpl extends IdentifiableDaoBase<TermVocabulary> implements

		ITermVocabularyDao {

	/**

	 * @param type

	 */

	public TermVocabularyDaoImpl() {

		super(TermVocabulary.class);

		indexedClasses = new Class[2];

		indexedClasses[0] = TermVocabulary.class;

		indexedClasses[1] = OrderedTermVocabulary.class;

	}

	@Override

    public long countTerms(TermVocabulary termVocabulary) {

		AuditEvent auditEvent = getAuditEventFromContext();

		if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {

		    Query query = getSession().createQuery("select count(term) from DefinedTermBase term where term.vocabulary = :vocabulary");

		    query.setParameter("vocabulary", termVocabulary);

		    return (Long)query.uniqueResult();

		} else {

			AuditQuery query = makeAuditQuery(null, auditEvent);

			query.addProjection(AuditEntity.id().count());

			query.add(AuditEntity.relatedId("vocabulary").eq(termVocabulary.getId()));

			return (Long)query.getSingleResult();

		}

	}

	@Override

    public <T extends DefinedTermBase> List<T> getTerms(TermVocabulary<T> vocabulary,Integer pageSize, Integer pageNumber, List<OrderHint> orderHints,List<String> propertyPaths) {

		AuditEvent auditEvent = getAuditEventFromContext();

		if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {

			Criteria criteria = getCriteria(DefinedTermBase.class);

			criteria.createCriteria("vocabulary").add(Restrictions.idEq(vocabulary.getId()));

			addPageSizeAndNumber(criteria, pageSize, pageNumber);

		    this.addOrder(criteria, orderHints);

		    @SuppressWarnings("unchecked")

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

		    defaultBeanInitializer.initializeAll(result, propertyPaths);

		    return result;

		} else {

			AuditQuery query = makeAuditQuery(null, auditEvent);

			query.add(AuditEntity.relatedId("vocabulary").eq(vocabulary.getId()));

			addPageSizeAndNumber(query, pageSize, pageNumber);

			@SuppressWarnings("unchecked")

            List<T> result = query.getResultList();

		    defaultBeanInitializer.initializeAll(result, propertyPaths);

			return result;

		}

	}

    @Override

    public <T extends DefinedTermBase> TermVocabulary<T> findByUri(String termSourceUri, Class<T> clazz) {