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

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.UUID;

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

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

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

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 int 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);

	/**

     * Returns term vocabularies that contain terms of a certain class e.g. Feature, Modifier, State.

     *

     * @param <TERMCLASS>

     * @param clazz the term class of the terms in the vocabulary

     * @param includeSubclasses if <code>true</code> all subclasses of clazz will be included for computation of the result

     * @param includeEmptyVocs if <code>true</code> all vocabularies that do not contain any term will be included in 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

     */

	/**

     * @deprecated This method is deprecated as we are using {@link TermType} now.

     * It may be removed in a future version.

     */

	@Deprecated

	public <TERMCLASS extends DefinedTermBase> List<TermVocabulary<? extends TERMCLASS>> listByTermClass(Class<TERMCLASS> clazz, boolean includeSubclasses, boolean includeEmptyVocs, Integer limit, Integer start, 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

     * @return a List of vocabularies

     */

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

	/**

     * 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);

	/**

	 * Returns all empty vocabularies.

	 * @param limit

	 * @param start

	 * @param orderHints

	 * @param propertyPaths

	 * @return

	 */

	public List<TermVocabulary> listEmpty(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);

}

/**

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

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

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

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

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

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

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 int 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()).intValue();

		} else {

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

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

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

			return ((Number)query.getSingleResult()).intValue();

		}

	}

	@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 = getSession().createCriteria(DefinedTermBase.class);

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

		    if(pageSize != null) {

		    	criteria.setMaxResults(pageSize);

		        if(pageNumber != null) {

		        	criteria.setFirstResult(pageNumber * pageSize);

		        }

		    }

		    this.addOrder(criteria, orderHints);

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

		    defaultBeanInitializer.initializeAll(result, propertyPaths);

		    return result;

		} else {

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

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

			if(pageSize != null) {

			    query.setMaxResults(pageSize);

		        if(pageNumber != null) {

		    	    query.setFirstResult(pageNumber * pageSize);

		        }

			}

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

		    defaultBeanInitializer.initializeAll(result, propertyPaths);

			return result;

		}

	}

	@Override

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

		AuditEvent auditEvent = getAuditEventFromContext();

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

    		Query query = getSession().createQuery("select vocabulary from TermVocabulary vocabulary where vocabulary.termSourceUri= :termSourceUri");

	    	query.setParameter("termSourceUri", termSourceUri);

		    return (TermVocabulary<T>)query.uniqueResult();

		} else {

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

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

			return (TermVocabulary<T>)query.getSingleResult();

		}

	}

	@Override

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

		return getTerms(termVocabulary, pageSize, pageNumber, null, null);

	}

	@Override

    @Deprecated

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

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

		List<Integer> intermediateResults;

		if (includeSubclasses){

			String hql = " SELECT DISTINCT trm.vocabulary.id " +

					" FROM %s trm " +

					" GROUP BY trm.vocabulary ";

			hql = String.format(hql, clazz.getSimpleName());

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

			intermediateResults = query.list();

		}else{

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

			criteria.createAlias("terms", "trms").add(Restrictions.eq("trms.class", clazz.getSimpleName()));

			criteria.setProjection(Projections.id());

			intermediateResults = criteria.list();

		}

		if (includeEmptyVocs){

			intermediateResults.addAll(getEmptyVocIds());

		}

		if(intermediateResults.size() == 0) {

			return new ArrayList<TermVocabulary<? extends TERM>>();

		}

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

		criteria.add(Restrictions.in("id", intermediateResults));

		if(limit != null) {

		    criteria.setMaxResults(limit);

	        if(start != null) {

	    	    criteria.setFirstResult(start);

	        }

		}

		this.addOrder(criteria, orderHints);

		List<TermVocabulary<? extends TERM>> result = criteria.list();

	    defaultBeanInitializer.initializeAll(result, propertyPaths);

		return result;

	}

//  public <T extends DefinedTermBase> List<TermVocabulary<T>> findByTermType(TermType termType) {

//

//      Query query = getSession().createQuery("select vocabulary from TermVocabulary vocabulary where vocabulary.termType= :termType");

//      query.setParameter("termType", termType);

//

//      return (List<TermVocabulary<T>>)query.list();

//

//  }

    @Override

    public <T extends DefinedTermBase> List<TermVocabulary<T>> findByTermType(TermType termType) {

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

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

        //this.addOrder(criteria, orderHints);

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

        defaultBeanInitializer.initializeAll(result, null);

        return result;

    }

	@Override

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

        checkNotInPriorView("TermVocabularyDao.listByTermType(TermType termType, Integer limit, Integer start, List<OrderHint> orderHints, List<String> propertyPaths)");

        Set<TermType> allTermTypes = new HashSet<TermType>();

        allTermTypes.add(termType);

        if (includeSubTypes){

            allTermTypes.addAll(termType.getGeneralizationOf(true));

        }

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

        criteria.add(Restrictions.in("termType", allTermTypes));

        if(limit != null) {

            criteria.setMaxResults(limit);

            if(start != null) {

                criteria.setFirstResult(start);

            }

        }

        this.addOrder(criteria, orderHints);

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

        defaultBeanInitializer.initializeAll(result, propertyPaths);

        return result;

    }

	@Override

    public List<TermVocabulary> listEmpty(Integer limit, Integer start,List<OrderHint> orderHints, List<String> propertyPaths) {

		checkNotInPriorView("TermVocabularyDao.listEmpty(Integer limit, Integer start,	List<OrderHint> orderHints, List<String> propertyPaths)");

		List<Integer> intermediateResults;

		intermediateResults = getEmptyVocIds();

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

		criteria.add(Restrictions.in("id", intermediateResults));

		if(limit != null) {

		    criteria.setMaxResults(limit);

	        if(start != null) {

	    	    criteria.setFirstResult(start);

	        }

		}

		this.addOrder(criteria, orderHints);

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

	    defaultBeanInitializer.initializeAll(result, propertyPaths);

		return result;

	}

	@Override

	public void missingTermUuids(

			Map<UUID, Set<UUID>> uuidsRequested,

			Map<UUID, Set<UUID>> uuidMissingTermsRepsonse,

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

		Set<UUID> missingTermCandidateUuids = new HashSet<UUID>();

		for (Set<UUID> uuidsPerVocSet : uuidsRequested.values()){

			missingTermCandidateUuids.addAll(uuidsPerVocSet);

		}

 		//search persisted subset of required (usually all)

		String hql = " SELECT terms.uuid " +

				" FROM TermVocabulary voc join voc.terms terms  " +

				" WHERE terms.uuid IN (:uuids) " +

				" ORDER BY voc.uuid ";

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

		query.setParameterList("uuids", missingTermCandidateUuids);

		List<?> persistedUuids = query.list();

 		//fully load and initialize vocabularies if required

		if (vocabularyResponse != null){

			String hql2 = " SELECT DISTINCT voc " +

					" FROM TermVocabulary voc " +

						" LEFT JOIN FETCH voc.terms terms " +

						" LEFT JOIN FETCH terms.representations representations " +

						" LEFT JOIN FETCH voc.representations vocReps " +

					" WHERE terms.uuid IN (:termUuids) OR  (  voc.uuid IN (:vocUuids)  ) " +  //was: AND voc.terms is empty, but did not load originally empty vocabularies with user defined terms added

//					" WHERE  voc.uuid IN (:vocUuids) AND voc.terms is empty  " +

					" ORDER BY voc.uuid ";

			query = getSession().createQuery(hql2);

			query.setParameterList("termUuids",missingTermCandidateUuids);

			query.setParameterList("vocUuids",uuidsRequested.keySet());

			List<TermVocabulary> o = query.list();

			for (TermVocabulary<?> voc : o){

				vocabularyResponse.put(voc.getUuid(), voc);

			}

		}

		//compute missing terms

		if (missingTermCandidateUuids.size() == persistedUuids.size()){

			missingTermCandidateUuids.clear();

		}else{

			missingTermCandidateUuids.removeAll(persistedUuids);

			//add missing terms to response

			for (UUID vocUUID : uuidsRequested.keySet()){

				for (UUID termUuid : uuidsRequested.get(vocUUID)){

					if (missingTermCandidateUuids.contains(termUuid)){

						Set<UUID> r = uuidMissingTermsRepsonse.get(vocUUID);

						if (r == null){

							r = new HashSet<UUID>();

							uuidMissingTermsRepsonse.put(vocUUID, r);

						}

						r.add(termUuid);

					}

				}

			}

		}

		return;

	}

	/**

	 * @return

	 */

	private List<Integer> getEmptyVocIds() {

		List<Integer> intermediateResults;

		String hql = " SELECT voc.id " +

				" FROM TermVocabulary voc " +

				" WHERE voc.terms.size = 0 ";

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

		intermediateResults = query.list();

		return intermediateResults;

	}

}

/**

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

import static org.junit.Assert.assertEquals;

import static org.junit.Assert.assertFalse;

import java.io.FileNotFoundException;

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.apache.log4j.Logger;

import org.junit.Assert;

import org.junit.Before;

import org.junit.Test;

import org.unitils.dbunit.annotation.DataSet;

import org.unitils.spring.annotation.SpringBeanByType;

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

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

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

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

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

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

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

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

import eu.etaxonomy.cdm.test.integration.CdmIntegrationTest;

/**

 * @author a.babadshanjan

 * @created 10.02.2009

 */

public class TermVocabularyDaoImplTest extends CdmIntegrationTest {

	@SuppressWarnings("unused")

	private static Logger logger = Logger.getLogger(TermVocabularyDaoImplTest.class);

	@SpringBeanByType

	private ITermVocabularyDao dao;

	@Before

	public void setUp() {}

   @Test

    public void testListVocabularyByType() {

        //test class with no subclasses

        List<TermVocabulary> rankVocabularies = dao.listByTermType(TermType.Rank, false, null, null, null, null);

        assertFalse("There should be at least one vocabulary containing terms of type Rank", rankVocabularies.isEmpty());

        assertEquals("There should be only one vocabulary containing terms of type Rank", 1, rankVocabularies.size());

        //include subtype, but termtype has no subtype

        rankVocabularies = dao.listByTermType(TermType.Rank, true, null, null, null, null);

        assertFalse("There should be at least one vocabulary containing terms of type Rank", rankVocabularies.isEmpty());

        assertEquals("There should be only one vocabulary containing terms of type Rank", 1, rankVocabularies.size());

        //with different classes

        List<TermVocabulary> namedAreaVocabularies = dao.listByTermType(TermType.NamedArea, true, null, null, null, null);

        int subclassedSize = namedAreaVocabularies.size();

        assertEquals("There should be 4 vocabularies (TdwgAreas, Continents, Waterbody, Countries)", 4, subclassedSize);

        //with sub types

        List<TermVocabulary> scopeVocabularies = dao.listByTermType(TermType.Scope, true, null, null, null, null);

        int subtypeSize = scopeVocabularies.size();

        assertEquals("There should be 6 vocabularies (Scope, Sex, Stage, 3 x KindOfUnit)", 6, subtypeSize);

        List<TermVocabulary> scopeOnlyVocabularies = dao.listByTermType(TermType.Scope, false, null, null, null, null);

        assertEquals("Scope only vocabularies w/o subtypes should be 1", 1, scopeOnlyVocabularies.size());

        List<TermVocabulary> stageVocabularies = dao.listByTermType(TermType.Stage, false, null, null, null, null);

        assertEquals("Stage only vocabularies should be 1", 1, stageVocabularies.size());

    }

    @Test

    @DataSet("TermVocabularyDaoImplTest.testListVocabularyEmpty.xml")

    public void testListVocabularyByTypeEmpty() {

        List<TermVocabulary> emptyNamedAreas = dao.listByTermType(TermType.NamedArea, true, null, null, null, null);

        assertEquals("There should be no vocabulary, as we do not return ALL empty vocabularies of ANY type anymore", 0, emptyNamedAreas.size());

        List<TermVocabulary> languageVocabulariesAndEmpty = dao.listByTermType(TermType.Language, true, null, null, null, null);

        assertEquals("There should be 2 vocabularies, the empty one and the one that has a language term in", 2, languageVocabulariesAndEmpty.size());

    }

	@Test

	public void testListVocabularyByClass() {

		//test class with no subclasses

		List<TermVocabulary<? extends Rank>> rankVocabularies = dao.listByTermClass(Rank.class, false, false, null, null, null, null);

		assertFalse("There should be at least one vocabulary containing terms of class Rank",rankVocabularies.isEmpty());

		assertEquals("There should be only one vocabulary containing terms of class Rank",1,rankVocabularies.size());

		rankVocabularies = dao.listByTermClass(Rank.class, true, false, null, null, null, null);

		assertFalse("There should be at least one vocabulary containing terms of class Rank",rankVocabularies.isEmpty());

		assertEquals("There should be only one vocabulary containing terms of class Rank",1,rankVocabularies.size());

		//with subclasses

		List<TermVocabulary<? extends NamedArea>> namedAreaVocabularies = dao.listByTermClass(NamedArea.class, true, false, null, null, null, null);

		int subclassedSize = namedAreaVocabularies.size();

		assertEquals("There should be 3 vocabularies (TdwgAreas, Continents, WaterbodyOrCountries)", 4, subclassedSize);

		List<TermVocabulary<? extends NamedArea>> namedAreaOnlyVocabularies = dao.listByTermClass(NamedArea.class, false, false, null, null, null, null);

		List<TermVocabulary<? extends Country>> countryVocabularies = dao.listByTermClass(Country.class, false, false, null, null, null, null);

		int sumOfSingleSizes = namedAreaOnlyVocabularies.size() + countryVocabularies.size();

		assertEquals("number of NamedArea and subclasses should be same as sum of all single vocabularies", subclassedSize, sumOfSingleSizes);

	}

	@Test

	@DataSet("TermVocabularyDaoImplTest.testListVocabularyEmpty.xml")

	public void testListVocabularyByClassEmpty() {

		//test include empty

		List<TermVocabulary<? extends NamedArea>> namedAreaVocabulariesAndEmpty = dao.listByTermClass(NamedArea.class, true, true, null, null, null, null);

		assertEquals("There should be 1 vocabulary (the empty one)", 1, namedAreaVocabulariesAndEmpty.size());

		List<TermVocabulary<? extends Language>> languageVocabulariesAndEmpty = dao.listByTermClass(Language.class, true, true, null, null, null, null);

		assertEquals("There should be 2 vocabularies, the empty one and the one that has a language term in", 2, languageVocabulariesAndEmpty.size());

	}

	@Test

	@DataSet("TermVocabularyDaoImplTest.testListVocabularyEmpty.xml")

	public void testListVocabularyEmpty() {

		//test class with no subclasses

		List<TermVocabulary> emptyVocs = dao.listEmpty(null, null, null, null);

		assertFalse("There should be at least one vocabulary containing no terms",emptyVocs.isEmpty());

		assertEquals("There should be only one vocabulary containing terms of class Rank",1,emptyVocs.size());

		UUID uuidEmptyVoc = UUID.fromString("f253962f-d787-4b16-b2d2-e645da73ae4f");

		assertEquals("The empty vocabulary should be the one defined", uuidEmptyVoc, emptyVocs.get(0).getUuid());

	}

	@Test

	public void testMissingTermUuids() {

		Set<UUID> uuidSet = new HashSet<UUID>();

		uuidSet.add(Language.uuidEnglish);

		uuidSet.add(Language.uuidFrench);

		UUID uuidNotExisting = UUID.fromString("e93e8c10-d9d2-4ad6-9907-952da6d139c4");

		uuidSet.add(uuidNotExisting);

		Map<UUID, Set<UUID>> uuidVocs = new HashMap<UUID, Set<UUID>>();

		uuidVocs.put( Language.uuidLanguageVocabulary, uuidSet);

		Map<UUID, Set<UUID>> notExisting = new HashMap<UUID, Set<UUID>>();

		Map<UUID, TermVocabulary<?>> vocabularyMap = new HashMap<UUID, TermVocabulary<?>>();

		dao.missingTermUuids(uuidVocs, notExisting, vocabularyMap);

		//assert missing terms

		assertEquals(Integer.valueOf(1), Integer.valueOf(notExisting.keySet().size()));

		assertEquals(Language.uuidLanguageVocabulary, notExisting.keySet().iterator().next());

		Set<UUID> missingLanguageTerms = notExisting.get(Language.uuidLanguageVocabulary );

		assertEquals(Integer.valueOf(1), Integer.valueOf(missingLanguageTerms.size()));

		assertEquals(uuidNotExisting, missingLanguageTerms.iterator().next());

	}

	@Test

    public void testTitleCacheCreation() {

	    //prepare

	    UUID vocUuid = UUID.fromString("a7a2fbe4-3a35-4ec0-b2b2-2298c3ebdf57");

	    TermVocabulary<?> newVoc = TermVocabulary.NewInstance(TermType.Modifier);

	    newVoc.setUuid(vocUuid);

	    //default titleCache

	    dao.save(newVoc);

	    newVoc.setProtectedTitleCache(true);  //make sure we use the title cache created during save by listeners

	    String emptyLabel = newVoc.getTitleCache();

	    //this value may need to be changed when the default cache generation changes

	    Assert.assertEquals("TitleCache should use default title generation", "TermVocabulary<a7a2fbe4-3a35-4ec0-b2b2-2298c3ebdf57>", emptyLabel);

	    //only German

	    newVoc.setProtectedTitleCache(false);

	    Representation newRepresentation = Representation.NewInstance("Beschreibung", "Deutsches Label", "Abk.", Language.GERMAN());

	    newVoc.addRepresentation(newRepresentation);

	    dao.saveOrUpdate(newVoc);

	    newVoc.setProtectedTitleCache(true);

	    Assert.assertEquals("German Label should be new title cache", "Deutsches Label", newVoc.getTitleCache());

	    //German and English

	    newVoc.setProtectedTitleCache(false);

        Representation englishRepresentation = Representation.NewInstance("Description", "English label", "Abbrev.", Language.DEFAULT());

        newVoc.addRepresentation(englishRepresentation);

        dao.saveOrUpdate(newVoc);

        newVoc.setProtectedTitleCache(true);

        Assert.assertEquals("English Label should be new title cache", "English label", newVoc.getTitleCache());

        //Change English label

        newVoc.setProtectedTitleCache(false);

        newVoc.setLabel("New English label");

        dao.saveOrUpdate(newVoc);

        newVoc.setProtectedTitleCache(true);

        Assert.assertEquals("English (default language) label should be new English label", "New English label", newVoc.getTitleCache());

        //Remove English

        newVoc.setProtectedTitleCache(false);

        newVoc.removeRepresentation(englishRepresentation);

        dao.saveOrUpdate(newVoc);

        newVoc.setProtectedTitleCache(true);

        Assert.assertEquals("German Label should be new title cache again as English representation is not there anymore", "Deutsches Label", newVoc.getTitleCache());

	}

    @Override

    public void createTestDataSet() throws FileNotFoundException {}

/**

* 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.api.service;

import java.util.List;

import eu.etaxonomy.cdm.api.service.pager.Pager;

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

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

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

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

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

public interface IVocabularyService extends IIdentifiableEntityService<TermVocabulary> {

    /**

     * Returns term vocabularies that contain terms of a certain class e.g. Feature, Modifier, State.

     *

     * @param <TERM>

     * @param clazz the term class of the terms in the vocabulary

     * @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

     * @see #listByTermClass(Class, boolean, Integer, Integer, List, List)

     * @deprecated use {@link #listByTermType(TermType, boolean, boolean, Integer, Integer, List, List)} instead.

     * May be removed in future versions.

     */

    @Deprecated

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

	/**

     * Returns term vocabularies that contain terms of a certain class e.g. Feature, Modifier, State.

     *

     * @param <TERM>

     * @param clazz the term class of the terms in the vocabulary

     * @param includeSubclasses if <code>true</code> all subclasses of clazz will be included for computation of the result

     * @param includeEmptyVocs if <code>true</code> all vocabularies that do not contain any term will be included in 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

     * @see #listByTermClass(Class, Integer, Integer, List, List)

     * @deprecated use {@link #listByTermType(TermType, boolean, boolean, Integer, Integer, List, List)} instead.

     * May be removed in future versions.

     */

	@Deprecated

	public <TERM extends DefinedTermBase> List<TermVocabulary<? extends TERM>> listByTermClass(Class<TERM> clazz, boolean includeSubclasses, boolean includeEmptyVocs, Integer limit, Integer start, List<OrderHint> orderHints, 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 includeEmptyVocs if <code>true</code> all vocabularies that do not contain any term will be included in 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, Integer limit, Integer start, List<OrderHint> orderHints, 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);

	/**

	 * Returns Language Vocabulary

	 * @return

	 */

	//TODO candidate for harmonization: rename to loadLanguageVocabulary(...

	public TermVocabulary<Language> getLanguageVocabulary();

	/**

	 * Returns a list of terms belonging to the vocabulary passed as an argument

	 *

	 * @param vocabulary The vocabulary for which the list of terms is desired

	 * @param limit The maximum number of terms returned (can be null for all terms in the vocabulary)

	 * @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 paged list of terms

	 */

	//TODO candidate for harmonization: rename to getTerms(...

	public Pager<DefinedTermBase> getTerms(TermVocabulary vocabulary, Integer limit, Integer start, List<OrderHint> orderHints, List<String> propertyPaths);

	/**

	 * Returns a list of term vocabularies corresponding to a term type

	 *