X-Git-Url: https://dev.e-taxonomy.eu/gitweb/cdmlib.git/blobdiff_plain/cba96ea5c6cb5b99a4bc5a2d6906c39c5364189d..e7b0669119e9bd65be692850b5277500e3fb36d9:/cdmlib-services/src/main/java/eu/etaxonomy/cdm/api/service/TaxonServiceImpl.java

diff --git a/cdmlib-services/src/main/java/eu/etaxonomy/cdm/api/service/TaxonServiceImpl.java b/cdmlib-services/src/main/java/eu/etaxonomy/cdm/api/service/TaxonServiceImpl.java
index 12470f9778..2b8b30bcaf 100644
--- a/cdmlib-services/src/main/java/eu/etaxonomy/cdm/api/service/TaxonServiceImpl.java
+++ b/cdmlib-services/src/main/java/eu/etaxonomy/cdm/api/service/TaxonServiceImpl.java
@@ -11,35 +11,38 @@
 package eu.etaxonomy.cdm.api.service;
 
 import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
 import java.util.Comparator;
 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.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
-import org.springframework.transaction.TransactionStatus;
+import org.springframework.transaction.annotation.Propagation;
 import org.springframework.transaction.annotation.Transactional;
 
 import eu.etaxonomy.cdm.api.service.config.ITaxonServiceConfigurator;
 import eu.etaxonomy.cdm.api.service.pager.Pager;
 import eu.etaxonomy.cdm.api.service.pager.impl.DefaultPagerImpl;
 import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;
+import eu.etaxonomy.cdm.model.common.CdmBase;
 import eu.etaxonomy.cdm.model.common.IdentifiableEntity;
 import eu.etaxonomy.cdm.model.common.OrderedTermVocabulary;
 import eu.etaxonomy.cdm.model.common.RelationshipBase;
-import eu.etaxonomy.cdm.model.description.CommonTaxonName;
-import eu.etaxonomy.cdm.model.description.DescriptionBase;
+import eu.etaxonomy.cdm.model.common.RelationshipBase.Direction;
+import eu.etaxonomy.cdm.model.common.UuidAndTitleCache;
+import eu.etaxonomy.cdm.model.description.DescriptionElementBase;
 import eu.etaxonomy.cdm.model.description.TaxonDescription;
+import eu.etaxonomy.cdm.model.media.Media;
+import eu.etaxonomy.cdm.model.media.MediaRepresentation;
+import eu.etaxonomy.cdm.model.media.MediaUtils;
 import eu.etaxonomy.cdm.model.name.HomotypicalGroup;
 import eu.etaxonomy.cdm.model.name.Rank;
 import eu.etaxonomy.cdm.model.name.TaxonNameBase;
-import eu.etaxonomy.cdm.model.reference.ReferenceBase;
+import eu.etaxonomy.cdm.model.reference.Reference;
+import eu.etaxonomy.cdm.model.taxon.Classification;
 import eu.etaxonomy.cdm.model.taxon.Synonym;
 import eu.etaxonomy.cdm.model.taxon.SynonymRelationship;
 import eu.etaxonomy.cdm.model.taxon.SynonymRelationshipType;
@@ -48,46 +51,33 @@ import eu.etaxonomy.cdm.model.taxon.TaxonBase;
 import eu.etaxonomy.cdm.model.taxon.TaxonNode;
 import eu.etaxonomy.cdm.model.taxon.TaxonRelationship;
 import eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType;
-import eu.etaxonomy.cdm.model.taxon.TaxonomicTree;
-import eu.etaxonomy.cdm.persistence.dao.BeanInitializer;
 import eu.etaxonomy.cdm.persistence.dao.common.IOrderedTermVocabularyDao;
 import eu.etaxonomy.cdm.persistence.dao.description.IDescriptionDao;
 import eu.etaxonomy.cdm.persistence.dao.name.ITaxonNameDao;
 import eu.etaxonomy.cdm.persistence.dao.taxon.ITaxonDao;
-import eu.etaxonomy.cdm.persistence.dao.taxon.ITaxonNodeDao;
-import eu.etaxonomy.cdm.persistence.dao.taxon.ITaxonomicTreeDao;
 import eu.etaxonomy.cdm.persistence.fetch.CdmFetch;
+import eu.etaxonomy.cdm.persistence.query.MatchMode;
 import eu.etaxonomy.cdm.persistence.query.OrderHint;
-import eu.etaxonomy.cdm.persistence.query.SelectMode;
 
 
+/**
+ * @author a.kohlbecker
+ * @date 10.09.2010
+ *
+ */
 @Service
-@Transactional(readOnly = true)
-public class TaxonServiceImpl extends IdentifiableServiceBase<TaxonBase,ITaxonDao> implements ITaxonService {
+@Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
+public class TaxonServiceImpl extends IdentifiableServiceBase<TaxonBase,ITaxonDao> implements ITaxonService{
 	private static final Logger logger = Logger.getLogger(TaxonServiceImpl.class);
 
 	@Autowired
 	private ITaxonNameDao nameDao;
-	@Autowired
-	private ITaxonomicTreeDao taxonTreeDao;
-	@Autowired
-	private ITaxonNodeDao taxonNodeDao;
-//	@Autowired
-//	@Qualifier("nonViralNameDaoHibernateImpl")
-//	private INonViralNameDao nonViralNameDao;
-	@Autowired
-	private IOrderedTermVocabularyDao orderedVocabularyDao;
-	@Autowired
-	private IDescriptionDao descriptionDao;
-	@Autowired
-	private BeanInitializer defaultBeanInitializer;
 	
-	private Comparator<? super TaxonNode> taxonNodeComparator;
-	@Autowired
-	public void setTaxonNodeComparator(ITaxonNodeComparator<? super TaxonNode> taxonNodeComparator){
-		this.taxonNodeComparator = (Comparator<? super TaxonNode>) taxonNodeComparator;
-	}
+	@Autowired 
+	private IDescriptionDao descriptionDao;
 
+	@Autowired
+	private IOrderedTermVocabularyDao orderedVocabularyDao;
 	
 	/**
 	 * Constructor
@@ -95,220 +85,74 @@ public class TaxonServiceImpl extends IdentifiableServiceBase<TaxonBase,ITaxonDa
 	public TaxonServiceImpl(){
 		if (logger.isDebugEnabled()) { logger.debug("Load TaxonService Bean"); }
 	}
-	
-	/* (non-Javadoc)
-	 * @see eu.etaxonomy.cdm.api.service.ITaxonService#getTaxonByUuid(java.util.UUID)
-	 */
-	public TaxonBase getTaxonByUuid(UUID uuid) {
-		return super.findByUuid(uuid);
-	}
-	
-	/*
-	 * (non-Javadoc)
-	 * @see eu.etaxonomy.cdm.api.service.ITaxonService#getTaxonNodeByUuid(java.util.UUID)
-	 */
-	public TaxonNode getTaxonNodeByUuid(UUID uuid) {
-		return taxonNodeDao.findByUuid(uuid);
-	}
-	
-	public TaxonNode loadTaxonNodeByTaxon(Taxon taxon, UUID taxonomicTreeUuid, List<String> propertyPaths){
-		TaxonomicTree tree = taxonTreeDao.load(taxonomicTreeUuid);
-		TaxonNode node = tree.getNode(taxon);
-		defaultBeanInitializer.initialize(node, propertyPaths);
-		return node;
-	}
-	
-	public List<TaxonNode> loadRankSpecificRootNodes(TaxonomicTree taxonomicTree, Rank rank, List<String> propertyPaths){
-		TaxonomicTree tree = taxonTreeDao.load(taxonomicTree.getUuid());
-		
-		List<TaxonNode> rootNodes = tree.getRankSpecificRootNodes(rank);
-		//sort nodes by TaxonName
-		
-		Collections.sort(rootNodes, taxonNodeComparator);
-		
-		// initialize all nodes
-		defaultBeanInitializer.initializeAll(rootNodes, propertyPaths);
-		
-		return rootNodes;
-	}
-	
-	public List<TaxonNode> loadTreeBranchTo(TaxonNode taxonNode, Rank baseRank, List<String> propertyPaths){
-		
-		TaxonNode thisNode = taxonNodeDao.load(taxonNode.getUuid(), propertyPaths);
-		List<TaxonNode> pathToRoot = new ArrayList<TaxonNode>();
-		pathToRoot.add(thisNode);
-		
-		TaxonNode parentNode = thisNode.getParent();
-		while(parentNode != null){
-			Rank parentNodeRank = parentNode.getTaxon().getName().getRank();
-			if(baseRank != null && baseRank.isLower(parentNodeRank)){
-				break;
-			}
-			pathToRoot.add(parentNode);
-			parentNode = parentNode.getParent();
-		}
-		
-		// initialize and invert order of nodes in list
-		defaultBeanInitializer.initializeAll(pathToRoot, propertyPaths);
-		Collections.reverse(pathToRoot);
-		
-		return pathToRoot;
-	}
-	
-	public List<TaxonNode> loadTreeBranchToTaxon(Taxon taxon, TaxonomicTree taxonomicTree, Rank baseRank, List<String> propertyPaths){
-		TaxonomicTree tree = taxonTreeDao.load(taxonomicTree.getUuid());
-		taxon = (Taxon)dao.load(taxon.getUuid());
-		TaxonNode node = tree.getNode(taxon);
-		return loadTreeBranchTo(node, baseRank, propertyPaths);
-	}
-	
-	public List<TaxonNode> loadChildNodesOfTaxon(Taxon taxon, TaxonomicTree taxonomicTree, List<String> propertyPaths){
-		TaxonomicTree tree = taxonTreeDao.load(taxonomicTree.getUuid());
-		taxon = (Taxon)dao.load(taxon.getUuid());
-		List<TaxonNode> childNodes = new ArrayList<TaxonNode>();
-		childNodes.addAll(tree.getNode(taxon).getChildNodes());
-		Collections.sort(childNodes, taxonNodeComparator);
-		defaultBeanInitializer.initializeAll(childNodes, propertyPaths);
-		return childNodes;
-	}
 
-	/* (non-Javadoc)
-	 * @see eu.etaxonomy.cdm.api.service.ITaxonService#saveTaxon(eu.etaxonomy.cdm.model.taxon.TaxonBase)
-	 */
-	@Transactional(readOnly = false)
-	public UUID saveTaxon(TaxonBase taxon) {
-		return super.saveCdmObject(taxon);
-	}
-	
-	/*
-	 * (non-Javadoc)
-	 * @see eu.etaxonomy.cdm.api.service.ITaxonService#saveTaxonNode(eu.etaxonomy.cdm.model.taxon.TaxonNode)
-	 */
-	@Transactional(readOnly = false)
-	public UUID saveTaxonNode(TaxonNode taxonNode) {
-		return taxonNodeDao.save(taxonNode);
-	}
-
-	//@Transactional(readOnly = false)
-	public UUID saveTaxon(TaxonBase taxon, TransactionStatus txStatus) {
-		//return super.saveCdmObject(taxon, txStatus);
-		return super.saveCdmObject(taxon);
-	}
-	
-	
-	/* (non-Javadoc)
-	 * @see eu.etaxonomy.cdm.api.service.ITaxonService#saveTaxonAll(java.util.Collection)
-	 */
-	@Transactional(readOnly = false)
-	public Map<UUID, ? extends TaxonBase> saveTaxonAll(Collection<? extends TaxonBase> taxonCollection){
-		return saveCdmObjectAll(taxonCollection);
-	}
-	
-	public Map<UUID, TaxonNode> saveTaxonNodeAll(
-			Collection<TaxonNode> taxonNodeCollection) {
-		return taxonNodeDao.saveAll(taxonNodeCollection);
-	}
-
-	/* (non-Javadoc)
-	 * @see eu.etaxonomy.cdm.api.service.ITaxonService#removeTaxon(eu.etaxonomy.cdm.model.taxon.TaxonBase)
+	/**
+	 * FIXME Candidate for harmonization
+	 * rename searchByName ? 
 	 */
-	@Transactional(readOnly = false)
-	public UUID removeTaxon(TaxonBase taxon) {
-		return super.removeCdmObject(taxon);
-	}
-
-	public List<TaxonBase> searchTaxaByName(String name, ReferenceBase sec) {
+	public List<TaxonBase> searchTaxaByName(String name, Reference sec) {
 		return dao.getTaxaByName(name, sec);
 	}
-
-	/* (non-Javadoc)
-	 * @see eu.etaxonomy.cdm.api.service.ITaxonService#getAllTaxonBases(int, int)
-	 */
-	public List<TaxonBase> getAllTaxonBases(int limit, int start){
-		return dao.list(limit, start);
-	}
-
-	/* (non-Javadoc)
-	 * @see eu.etaxonomy.cdm.api.service.ITaxonService#getAllTaxa(int, int)
-	 */
-	public List<Taxon> getAllTaxa(int limit, int start){
-		return dao.getAllTaxa(limit, start);
-	}
 	
-	/* (non-Javadoc)
+	/**
+	 * FIXME Candidate for harmonization
+	 * list(Synonym.class, ...)
+	 *  (non-Javadoc)
 	 * @see eu.etaxonomy.cdm.api.service.ITaxonService#getAllSynonyms(int, int)
 	 */
 	public List<Synonym> getAllSynonyms(int limit, int start) {
 		return dao.getAllSynonyms(limit, start);
 	}
-
-
-	/* (non-Javadoc)
-	 * @see eu.etaxonomy.cdm.api.service.ITaxonService#getAllTaxonomicTrees(int, int)
-	 * 
-	 */
-	@Deprecated
-	public List<TaxonomicTree> getAllTaxonomicTrees(int limit, int start) {
-		return taxonTreeDao.list(limit, start);
-	}
-	
-	public List<TaxonomicTree> listTaxonomicTrees(Integer limit, Integer start, List<OrderHint> orderHints, List<String> propertyPaths) {
-		return taxonTreeDao.list(limit, start, orderHints, propertyPaths);
-	}	
-
-	/* (non-Javadoc)
-	 * @see eu.etaxonomy.cdm.api.service.ITaxonService#getTaxonomicTreeByUuid(java.util.UUID)
-	 */
-	public TaxonomicTree getTaxonomicTreeByUuid(UUID uuid){
-		return taxonTreeDao.findByUuid(uuid);
-	}
-	
-	/*
-	 * (non-Javadoc)
-	 * @see eu.etaxonomy.cdm.api.service.ITaxonService#removeTaxonomicTree(java.util.UUID)
-	 */
-	@Transactional(readOnly = false)
-	public UUID removeTaxonomicTree(TaxonomicTree taxonomicTree) {
-		return taxonTreeDao.delete(taxonomicTree);
-	}
 	
-	/* (non-Javadoc)
-	 * @see eu.etaxonomy.cdm.api.service.ITaxonService#saveTaxonomicTree(eu.etaxonomy.cdm.model.taxon.TaxonomicTree)
+	/**
+	 * FIXME Candidate for harmonization
+	 * list(Taxon.class, ...)
+	 *  (non-Javadoc)
+	 * @see eu.etaxonomy.cdm.api.service.ITaxonService#getAllTaxa(int, int)
 	 */
-	@Transactional(readOnly = false)
-	public UUID saveTaxonomicTree(TaxonomicTree tree){
-		return taxonTreeDao.saveOrUpdate(tree);
+	public List<Taxon> getAllTaxa(int limit, int start) {
+		return dao.getAllTaxa(limit, start);
 	}
 
-	/* (non-Javadoc)
-	 * @see eu.etaxonomy.cdm.api.service.ITaxonService#getRootTaxa(eu.etaxonomy.cdm.model.reference.ReferenceBase)
+
+	/**
+	 * FIXME Candidate for harmonization
+	 * merge with getRootTaxa(Reference sec, ..., ...)
+	 *  (non-Javadoc)
+	 * @see eu.etaxonomy.cdm.api.service.ITaxonService#getRootTaxa(eu.etaxonomy.cdm.model.reference.Reference)
 	 */
-	public List<Taxon> getRootTaxa(ReferenceBase sec){
+	public List<Taxon> getRootTaxa(Reference sec){
 		return getRootTaxa(sec, CdmFetch.FETCH_CHILDTAXA(), true);
 	}
 
-	/* (non-Javadoc)
-	 * @see eu.etaxonomy.cdm.api.service.ITaxonService#getRootTaxa(eu.etaxonomy.cdm.model.reference.ReferenceBase, boolean)
+	/**
+	 * FIXME Candidate for harmonization
+	 * merge with getRootTaxa(Reference sec, ..., ...)
+	 *  (non-Javadoc)
+	 * @see eu.etaxonomy.cdm.api.service.ITaxonService#getRootTaxa(eu.etaxonomy.cdm.model.reference.Reference, boolean)
 	 */
-	public List<Taxon> getRootTaxa(ReferenceBase sec, CdmFetch cdmFetch, boolean onlyWithChildren) {
+	public List<Taxon> getRootTaxa(Reference sec, CdmFetch cdmFetch, boolean onlyWithChildren) {
 		if (cdmFetch == null){
 			cdmFetch = CdmFetch.NO_FETCH();
 		}
 		return dao.getRootTaxa(sec, cdmFetch, onlyWithChildren, false);
 	}
 	
-	/* (non-Javadoc)
-	 * @see eu.etaxonomy.cdm.api.service.ITaxonService#getRootTaxa(eu.etaxonomy.cdm.model.reference.ReferenceBase, boolean, boolean)
+	/**
+ 	 * FIXME Candidate for harmonization
+	 * merge with getRootTaxa(Reference sec, ..., ...)
+	 *  (non-Javadoc)
+	 * @see eu.etaxonomy.cdm.api.service.ITaxonService#getRootTaxa(eu.etaxonomy.cdm.model.reference.Reference, boolean, boolean)
 	 */
-	public List<Taxon> getRootTaxa(ReferenceBase sec, boolean onlyWithChildren,
+	public List<Taxon> getRootTaxa(Reference sec, boolean onlyWithChildren,
 			boolean withMisapplications) {
 		return dao.getRootTaxa(sec, null, onlyWithChildren, withMisapplications);
 	}
 
 	/* (non-Javadoc)
-	 * @see eu.etaxonomy.cdm.api.service.ITaxonService#getRootTaxa(eu.etaxonomy.cdm.model.name.Rank, eu.etaxonomy.cdm.model.reference.ReferenceBase, boolean, boolean)
+	 * @see eu.etaxonomy.cdm.api.service.ITaxonService#getRootTaxa(eu.etaxonomy.cdm.model.name.Rank, eu.etaxonomy.cdm.model.reference.Reference, boolean, boolean)
 	 */
-	public List<Taxon> getRootTaxa(Rank rank, ReferenceBase sec, boolean onlyWithChildren,
+	public List<Taxon> getRootTaxa(Rank rank, Reference sec, boolean onlyWithChildren,
 			boolean withMisapplications, List<String> propertyPaths) {
 		return dao.getRootTaxa(rank, sec, null, onlyWithChildren, withMisapplications, propertyPaths);
 	}
@@ -317,6 +161,11 @@ public class TaxonServiceImpl extends IdentifiableServiceBase<TaxonBase,ITaxonDa
 		return dao.getAllRelationships(limit, start);
 	}
 	
+	/**
+	 * FIXME Candidate for harmonization
+	 * is this the same as termService.getVocabulary(VocabularyEnum.TaxonRelationshipType) ? 
+	 */
+	@Deprecated
 	public OrderedTermVocabulary<TaxonRelationshipType> getTaxonRelationshipTypeVocabulary() {
 		
 		String taxonRelTypeVocabularyId = "15db0cf7-7afc-4a86-a7d4-221c73b0c9ac";
@@ -330,22 +179,31 @@ public class TaxonServiceImpl extends IdentifiableServiceBase<TaxonBase,ITaxonDa
 	 * @see eu.etaxonomy.cdm.api.service.ITaxonService#makeTaxonSynonym(eu.etaxonomy.cdm.model.taxon.Taxon, eu.etaxonomy.cdm.model.taxon.Taxon)
 	 */
 	@Transactional(readOnly = false)
-	public Synonym makeTaxonSynonym(Taxon oldTaxon, Taxon newAcceptedTaxon, SynonymRelationshipType synonymType, ReferenceBase citation, String citationMicroReference) {
-		if (oldTaxon == null || newAcceptedTaxon == null || oldTaxon.getName() == null){
-			return null;
+	public Synonym changeAcceptedTaxonToSynonym(TaxonNode oldTaxonNode, TaxonNode newAcceptedTaxonNode, SynonymRelationshipType synonymRelationshipType, Reference citation, String citationMicroReference) {
+
+		// TODO at the moment this method only moves synonym-, concept relations and descriptions to the new accepted taxon
+		// in a future version we also want to move cdm data like annotations, marker, so., but we will need a policy for that
+		if (oldTaxonNode == null || newAcceptedTaxonNode == null || oldTaxonNode.getTaxon().getName() == null){
+			throw new IllegalArgumentException("A mandatory parameter was null.");
 		}
 		
+		if(oldTaxonNode.equals(newAcceptedTaxonNode)){
+			throw new IllegalArgumentException("Taxon can not be made synonym of its own.");
+		}
+		
+		Taxon oldTaxon = (Taxon) HibernateProxyHelper.deproxy(oldTaxonNode.getTaxon());
+		Taxon newAcceptedTaxon = (Taxon) HibernateProxyHelper.deproxy(newAcceptedTaxonNode.getTaxon());
+		
 		// Move oldTaxon to newTaxon
 		TaxonNameBase<?,?> synonymName = oldTaxon.getName();
-		if (synonymType == null){
+		if (synonymRelationshipType == null){
 			if (synonymName.isHomotypic(newAcceptedTaxon.getName())){
-				synonymType = SynonymRelationshipType.HOMOTYPIC_SYNONYM_OF();
+				synonymRelationshipType = SynonymRelationshipType.HOMOTYPIC_SYNONYM_OF();
 			}else{
-				//TODO synonymType 
-				synonymType = SynonymRelationshipType.HETEROTYPIC_SYNONYM_OF();
+				synonymRelationshipType = SynonymRelationshipType.HETEROTYPIC_SYNONYM_OF();
 			}
 		}
-		SynonymRelationship synRel = newAcceptedTaxon.addSynonymName(synonymName, synonymType, citation, citationMicroReference);
+		SynonymRelationship synonmyRelationship = newAcceptedTaxon.addSynonymName(synonymName, synonymRelationshipType, citation, citationMicroReference);
 		
 		//Move Synonym Relations to new Taxon
 		for(SynonymRelationship synRelation : oldTaxon.getSynonymRelations()){
@@ -353,67 +211,44 @@ public class TaxonServiceImpl extends IdentifiableServiceBase<TaxonBase,ITaxonDa
 					synRelation.getCitation(), synRelation.getCitationMicroReference());
 		}
 
-		//Move Taxon RelationShips to new Taxon
-		Set<TaxonRelationship> removableTaxonRels = new HashSet<TaxonRelationship>();
-		for(TaxonRelationship taxonRelation : oldTaxon.getTaxonRelations()){
-			//CHILDREN
-			if (taxonRelation.getType().equals(TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN())){
-				if (taxonRelation.getFromTaxon() == oldTaxon){
-					removableTaxonRels.add(taxonRelation);
-//					oldTaxon.removeTaxonRelation(taxonRelation);
-				}else if(taxonRelation.getToTaxon() == oldTaxon){
-					newAcceptedTaxon.addTaxonomicChild(taxonRelation.getFromTaxon(), taxonRelation.getCitation(), taxonRelation.getCitationMicroReference());
-					removableTaxonRels.add(taxonRelation);
-//					oldTaxon.removeTaxonRelation(taxonRelation);
-				}else{
-					logger.warn("Taxon is not part of its own Taxonrelationship");
-				}
-			}
-			//MISAPPLIED NAMES
-			if (taxonRelation.getType().equals(TaxonRelationshipType.MISAPPLIED_NAME_FOR())){
-				if (taxonRelation.getFromTaxon() == oldTaxon){
-					newAcceptedTaxon.addMisappliedName(taxonRelation.getToTaxon(), taxonRelation.getCitation(), taxonRelation.getCitationMicroReference());
-					removableTaxonRels.add(taxonRelation);
-//					oldTaxon.removeTaxonRelation(taxonRelation);
-				}else if(taxonRelation.getToTaxon() == oldTaxon){
-					newAcceptedTaxon.addMisappliedName(taxonRelation.getFromTaxon(), taxonRelation.getCitation(), taxonRelation.getCitationMicroReference());
-					removableTaxonRels.add(taxonRelation);
-//					oldTaxon.removeTaxonRelation(taxonRelation);
-				}else{
-					logger.warn("Taxon is not part of its own Taxonrelationship");
-				}
+		
+		// CHILD NODES
+		if(oldTaxonNode.getChildNodes() != null && oldTaxonNode.getChildNodes().size() != 0){
+			for(TaxonNode childNode : oldTaxonNode.getChildNodes()){
+				newAcceptedTaxonNode.addChildNode(childNode, childNode.getReference(), childNode.getMicroReference(), childNode.getSynonymToBeUsed());
 			}
-			//Concept Relationships
-			//FIXME implement
-//			if (taxonRelation.getType().equals(TaxonRelationshipType.MISAPPLIEDNAMEFOR())){
-//				if (taxonRelation.getFromTaxon() == oldTaxon){
-//					newAcceptedTaxon.addMisappliedName(taxonRelation.getToTaxon(), taxonRelation.getCitation(), taxonRelation.getCitationMicroReference());
-//			        removableTaxonRels.add(taxonRelation);
-//				}else if(taxonRelation.getToTaxon() == oldTaxon){
-//					newAcceptedTaxon.addMisappliedName(taxonRelation.getFromTaxon(), taxonRelation.getCitation(), taxonRelation.getCitationMicroReference());
-//	                removableTaxonRels.add(taxonRelation);
-//				}else{
-//					logger.warn("Taxon is not part of its own Taxonrelationship");
-//				}
-//			}
 		}
 		
-		for(TaxonRelationship taxonRel : removableTaxonRels) {
-			oldTaxon.removeTaxonRelation(taxonRel);
+		//Move Taxon RelationShips to new Taxon
+		Set<TaxonRelationship> obsoleteTaxonRelationships = new HashSet<TaxonRelationship>();
+		for(TaxonRelationship taxonRelationship : oldTaxon.getTaxonRelations()){
+			Taxon fromTaxon = (Taxon) HibernateProxyHelper.deproxy(taxonRelationship.getFromTaxon());
+			Taxon toTaxon = (Taxon) HibernateProxyHelper.deproxy(taxonRelationship.getToTaxon());
+			if (fromTaxon == oldTaxon){
+				newAcceptedTaxon.addTaxonRelation(taxonRelationship.getToTaxon(), taxonRelationship.getType(), 
+						taxonRelationship.getCitation(), taxonRelationship.getCitationMicroReference());
+				
+			}else if(toTaxon == oldTaxon){
+				taxonRelationship.getFromTaxon().addTaxonRelation(newAcceptedTaxon, taxonRelationship.getType(), 
+						taxonRelationship.getCitation(), taxonRelationship.getCitationMicroReference());
+
+			}else{
+				logger.warn("Taxon is not part of its own Taxonrelationship");
+			}
+			// Remove old relationships
+			taxonRelationship.setToTaxon(null);
+			taxonRelationship.setFromTaxon(null);
 		}
 		
-		//Move Descriptions to new Taxon
-		for(TaxonDescription taxDescription : oldTaxon.getDescriptions()){
-			newAcceptedTaxon.addDescription(taxDescription);
+		//Move descriptions to new taxon
+		for(TaxonDescription description : oldTaxon.getDescriptions()){
+			description.setTitleCache("Description copied from former accepted taxon: " + oldTaxon.getTitleCache() + "(Old title: " + description.getTitleCache()  + ")");
+			newAcceptedTaxon.addDescription(description);
 		}
-		//delete old Taxon
-		this.dao.saveOrUpdate(newAcceptedTaxon);
-//		FIXME implement
-//		this.dao.delete(oldTaxon);
+				
+		oldTaxonNode.delete();
 		
-		//return
-//		this.dao.flush();
-		return synRel.getSynonym();
+		return synonmyRelationship.getSynonym();
 	}
 
 	/*
@@ -421,43 +256,70 @@ public class TaxonServiceImpl extends IdentifiableServiceBase<TaxonBase,ITaxonDa
 	 * @see eu.etaxonomy.cdm.api.service.ITaxonService#swapSynonymWithAcceptedTaxon(eu.etaxonomy.cdm.model.taxon.Synonym)
 	 */
 	@Transactional(readOnly = false)
-	public void makeSynonymAcceptedTaxon(Synonym synonym, Taxon acceptedTaxon, SynonymRelationshipType synonymRelationshipType){
+	public void swapSynonymAndAcceptedTaxon(Synonym synonym, Taxon acceptedTaxon){
 		
-		// create a new synonym with the old acceptedName
-		TaxonNameBase oldAcceptedTaxonName = acceptedTaxon.getName();
+		TaxonNameBase synonymName = synonym.getName();
+		synonymName.removeTaxonBase(synonym);
+		TaxonNameBase taxonName = acceptedTaxon.getName();
+		taxonName.removeTaxonBase(acceptedTaxon);
 		
-		// remove synonym from oldAcceptedTaxon
-		acceptedTaxon.removeSynonym(synonym);
+		synonym.setName(taxonName);
+		acceptedTaxon.setName(synonymName);
 		
-		// make synonym name the accepted taxons name
-		TaxonNameBase newAcceptedTaxonName = synonym.getName();
-		acceptedTaxon.setName(newAcceptedTaxonName);
+		// the accepted taxon needs a new uuid because the concept has changed
+		// FIXME this leads to an error "HibernateException: immutable natural identifier of an instance of eu.etaxonomy.cdm.model.taxon.Taxon was altered"
+		//acceptedTaxon.setUuid(UUID.randomUUID());
+	}
 		
-		// add the new synonym to the acceptedTaxon
-		if(synonymRelationshipType == null){
-			synonymRelationshipType = SynonymRelationshipType.SYNONYM_OF();
-		}
+	
+	/*
+	 * (non-Javadoc)
+	 * @see eu.etaxonomy.cdm.api.service.ITaxonService#makeSynonymAcceptedTaxon(eu.etaxonomy.cdm.model.taxon.Synonym, eu.etaxonomy.cdm.model.taxon.Taxon)
+	 */
+	public Taxon changeSynonymToAcceptedTaxon(Synonym synonym, Taxon acceptedTaxon){
 		
-		acceptedTaxon.addSynonymName(oldAcceptedTaxonName, synonymRelationshipType);
-	}
-
-	public void generateTitleCache() {
-		generateTitleCache(true);
+		Taxon newAcceptedTaxon = Taxon.NewInstance(synonym.getName(), acceptedTaxon.getSec());
+		
+		acceptedTaxon.removeSynonym(synonym);
+		
+		// since we are swapping names, we have to detach the name from the synonym completely. 
+		// Otherwise the synonym will still be in the list of typified names.
+		synonym.getName().removeTaxonBase(synonym);
+		
+		return newAcceptedTaxon;
 	}
-	//TODO
-	public void generateTitleCache(boolean forceProtected) {
-		logger.warn("generateTitleCache not yet fully implemented!");
-//		for (TaxonBase tb : taxonDao.getAllTaxa(null,null)){
-//			logger.warn("Old taxon title: " + tb.getTitleCache());
-//			if (forceProtected || !tb.isProtectedTitleCache() ){
-//				tb.setTitleCache(tb.generateTitle(), false);
-//				taxonDao.update(tb);
-//				logger.warn("New title: " + tb.getTitleCache());
-//			}
-//		}
+	
+	public Taxon changeSynonymToRelatedTaxon(Synonym synonym, Taxon toTaxon, TaxonRelationshipType taxonRelationshipType, Reference citation, String microcitation){
+		
+		// Get name from synonym
+		TaxonNameBase<?, ?> synonymName = synonym.getName();
+		
+		// remove synonym from taxon
+		toTaxon.removeSynonym(synonym);
+		
+		// Create a taxon with synonym name
+		Taxon fromTaxon = Taxon.NewInstance(synonymName, null);
 		
+		// Add taxon relation 
+		fromTaxon.addTaxonRelation(toTaxon, taxonRelationshipType, citation, microcitation);
+				
+		// since we are swapping names, we have to detach the name from the synonym completely. 
+		// Otherwise the synonym will still be in the list of typified names.
+		synonym.getName().removeTaxonBase(synonym);
+		
+		return fromTaxon;
 	}
 
+	/* (non-Javadoc)
+	 * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#updateTitleCache()
+	 */
+	@Override
+	@Transactional(readOnly = false)
+	public void updateTitleCache() {
+		Class<TaxonBase> clazz = TaxonBase.class;
+		super.updateTitleCache(clazz, null, null);
+	}
+	
 	@Autowired
 	protected void setDao(ITaxonDao dao) {
 		this.dao = dao;
@@ -474,6 +336,17 @@ public class TaxonServiceImpl extends IdentifiableServiceBase<TaxonBase,ITaxonDa
 		return new DefaultPagerImpl<TaxonBase>(pageNumber, numberOfResults, pageSize, results);
 	}
 
+	public List<TaxonBase> listTaxaByName(Class<? extends TaxonBase> clazz, String uninomial,	String infragenericEpithet, String specificEpithet,	String infraspecificEpithet, Rank rank, Integer pageSize,Integer pageNumber) {
+        Integer numberOfResults = dao.countTaxaByName(clazz, uninomial, infragenericEpithet, specificEpithet, infraspecificEpithet, rank);
+		
+		List<TaxonBase> results = new ArrayList<TaxonBase>();
+		if(numberOfResults > 0) { // no point checking again
+			results = dao.findTaxaByName(clazz, uninomial, infragenericEpithet, specificEpithet, infraspecificEpithet, rank, pageSize, pageNumber); 
+		}
+		
+		return results;
+	}
+
 	public List<TaxonRelationship> listToTaxonRelationships(Taxon taxon, TaxonRelationshipType type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths){
 		Integer numberOfResults = dao.countTaxonRelationships(taxon, type, TaxonRelationship.Direction.relatedTo);
 		
@@ -525,6 +398,17 @@ public class TaxonServiceImpl extends IdentifiableServiceBase<TaxonBase,ITaxonDa
 		return new DefaultPagerImpl<SynonymRelationship>(pageNumber, numberOfResults, pageSize, results);
 	}
 	
+	public Pager<SynonymRelationship> getSynonyms(Synonym synonym,	SynonymRelationshipType type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
+        Integer numberOfResults = dao.countSynonyms(synonym, type);
+		
+		List<SynonymRelationship> results = new ArrayList<SynonymRelationship>();
+		if(numberOfResults > 0) { // no point checking again
+			results = dao.getSynonyms(synonym, type, pageSize, pageNumber, orderHints, propertyPaths); 
+		}
+		
+		return new DefaultPagerImpl<SynonymRelationship>(pageNumber, numberOfResults, pageSize, results);
+	}
+	
 	public List<Synonym> getHomotypicSynonymsByHomotypicGroup(Taxon taxon, List<String> propertyPaths){
 		Taxon t = (Taxon)dao.load(taxon.getUuid(), propertyPaths);
 		return t.getHomotypicSynonymsByHomotypicGroup();
@@ -539,19 +423,10 @@ public class TaxonServiceImpl extends IdentifiableServiceBase<TaxonBase,ITaxonDa
 		}
 		return heterotypicSynonymyGroups;
 	}
-
-	public Pager<TaxonBase> search(Class<? extends TaxonBase> clazz, String queryString, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
-        Integer numberOfResults = dao.count(clazz,queryString);
-		
-		List<TaxonBase> results = new ArrayList<TaxonBase>();
-		if(numberOfResults > 0) { // no point checking again
-			results = dao.search(clazz,queryString, pageSize, pageNumber, orderHints, propertyPaths); 
-		}
-		
-		return new DefaultPagerImpl<TaxonBase>(pageNumber, numberOfResults, pageSize, results);
-	}
-
 	
+	/* (non-Javadoc)
+	 * @see eu.etaxonomy.cdm.api.service.ITaxonService#findTaxaAndNames(eu.etaxonomy.cdm.api.service.config.ITaxonServiceConfigurator)
+	 */
 	public Pager<IdentifiableEntity> findTaxaAndNames(ITaxonServiceConfigurator configurator) {
 		
 		List<IdentifiableEntity> results = new ArrayList<IdentifiableEntity>();
@@ -559,35 +434,38 @@ public class TaxonServiceImpl extends IdentifiableServiceBase<TaxonBase,ITaxonDa
 		List<TaxonBase> taxa = null; 
 
 		// Taxa and synonyms
+		long numberTaxaResults = 0L;
 		
-		int numberTaxaResults = 0;
-		
-		if (configurator.isDoTaxa() && configurator.isDoSynonyms()) {
-			taxa = dao.getTaxaByName(configurator.getSearchString(), 
-					configurator.getMatchMode(), SelectMode.ALL, configurator.getSec(),
-						configurator.getPageSize(), configurator.getPageNumber(), 
-						configurator.getTaxonPropertyPath());
-			numberTaxaResults = 
-				dao.countTaxaByName(configurator.getSearchString(), 
-						configurator.getMatchMode(), SelectMode.ALL, configurator.getSec());
-			
+		Class<? extends TaxonBase> clazz = null;
+		List<String> propertyPath = new ArrayList<String>();
+		if(configurator.getTaxonPropertyPath() != null){
+			propertyPath.addAll(configurator.getTaxonPropertyPath());
+		}
+		if ((configurator.isDoTaxa() && configurator.isDoSynonyms())) {
+			clazz = TaxonBase.class;
+			//propertyPath.addAll(configurator.getTaxonPropertyPath());
+			//propertyPath.addAll(configurator.getSynonymPropertyPath());
 		} else if(configurator.isDoTaxa()) {
-			taxa = dao.getTaxaByName(configurator.getSearchString(), 
-					configurator.getMatchMode(), SelectMode.TAXA, configurator.getSec(),
-					configurator.getPageSize(), configurator.getPageNumber(), 
-					configurator.getTaxonPropertyPath());
-			numberTaxaResults = 
-				dao.countTaxaByName(configurator.getSearchString(), 
-						configurator.getMatchMode(), SelectMode.TAXA, configurator.getSec());
-			
+			clazz = Taxon.class;
+			//propertyPath = configurator.getTaxonPropertyPath();
 		} else if (configurator.isDoSynonyms()) {
-			taxa = dao.getTaxaByName(configurator.getSearchString(), 
-					configurator.getMatchMode(), SelectMode.SYNONYMS, configurator.getSec(),
-					configurator.getPageSize(), configurator.getPageNumber(), 
-					configurator.getTaxonPropertyPath());
-			numberTaxaResults = 
-				dao.countTaxaByName(configurator.getSearchString(), 
-						configurator.getMatchMode(), SelectMode.SYNONYMS, configurator.getSec());
+			clazz = Synonym.class;
+			//propertyPath = configurator.getSynonymPropertyPath();
+		}
+		
+		if(clazz != null){
+			if(configurator.getPageSize() != null){ // no point counting if we need all anyway
+				numberTaxaResults = 
+					dao.countTaxaByName(clazz, 
+						configurator.getSearchString(), configurator.getClassification(), configurator.getMatchMode(),
+						configurator.getNamedAreas());
+			}
+			if(configurator.getPageSize() == null || numberTaxaResults > configurator.getPageSize() * configurator.getPageNumber()){ // no point checking again if less results
+				taxa = dao.getTaxaByName(clazz, 
+					configurator.getSearchString(), configurator.getClassification(), configurator.getMatchMode(),
+					configurator.getNamedAreas(), configurator.getPageSize(), 
+					configurator.getPageNumber(), propertyPath);
+			}
 		}
 
 		if (logger.isDebugEnabled()) { logger.debug(numberTaxaResults + " matching taxa counted"); }
@@ -597,14 +475,14 @@ public class TaxonServiceImpl extends IdentifiableServiceBase<TaxonBase,ITaxonDa
 		}
 		
 		numberOfResults += numberTaxaResults;
-		
+
 		// Names without taxa 
-		
 		if (configurator.isDoNamesWithoutTaxa()) {
             int numberNameResults = 0;
+           
 			List<? extends TaxonNameBase<?,?>> names = 
 				nameDao.findByName(configurator.getSearchString(), configurator.getMatchMode(), 
-						configurator.getPageSize(), configurator.getPageNumber(), null, null);
+						configurator.getPageSize(), configurator.getPageNumber(), null, configurator.getTaxonNamePropertyPath());
 			if (logger.isDebugEnabled()) { logger.debug(names.size() + " matching name(s) found"); }
 			if (names.size() > 0) {
 				for (TaxonNameBase<?,?> taxonName : names) {
@@ -619,44 +497,190 @@ public class TaxonServiceImpl extends IdentifiableServiceBase<TaxonBase,ITaxonDa
 		}
 		
 		// Taxa from common names
-		// FIXME the matching common names also must be returned
+		
 		if (configurator.isDoTaxaByCommonNames()) {
-			int numberCommonNameResults = 0;
-			List<CommonTaxonName> commonTaxonNames = 
-				descriptionDao.searchDescriptionByCommonName(configurator.getSearchString(), 
-						configurator.getMatchMode(), configurator.getPageSize(), configurator.getPageNumber());
-			if (logger.isDebugEnabled()) { logger.debug(commonTaxonNames.size() + " matching common name(s) found"); }
-			if (commonTaxonNames.size() > 0) {
-				for (CommonTaxonName commonTaxonName : commonTaxonNames) {
-					DescriptionBase description = commonTaxonName.getInDescription();
-					description = HibernateProxyHelper.deproxy(description, DescriptionBase.class);
-					if (description instanceof TaxonDescription) {
-						TaxonDescription taxonDescription = HibernateProxyHelper.deproxy(description, TaxonDescription.class);
-						Taxon taxon = taxonDescription.getTaxon();
-						taxon = HibernateProxyHelper.deproxy(taxon, Taxon.class);
-						if (!results.contains(taxon) && !taxon.isMisappliedName()) {
-							defaultBeanInitializer.initialize(taxon, configurator.getTaxonPropertyPath());
-							results.add(taxon);
-							numberCommonNameResults++;
-						}
+			taxa = null;
+			numberTaxaResults = 0;
+			if(configurator.getPageSize() != null){// no point counting if we need all anyway
+				numberTaxaResults = dao.countTaxaByCommonName(configurator.getSearchString(), configurator.getClassification(), configurator.getMatchMode(), configurator.getNamedAreas());
+			}
+			if(configurator.getPageSize() == null || numberTaxaResults > configurator.getPageSize() * configurator.getPageNumber()){
+				taxa = dao.getTaxaByCommonName(configurator.getSearchString(), configurator.getClassification(), configurator.getMatchMode(), configurator.getNamedAreas(), configurator.getPageSize(), configurator.getPageNumber(), configurator.getTaxonPropertyPath());
+			}
+			if(taxa != null){
+				results.addAll(taxa);
+			}
+			numberOfResults += numberTaxaResults;
+			 
+		}
+		
+	   return new DefaultPagerImpl<IdentifiableEntity>
+			(configurator.getPageNumber(), numberOfResults, configurator.getPageSize(), results);
+	}
+	
+	public List<UuidAndTitleCache<TaxonBase>> getTaxonUuidAndTitleCache(){
+		return dao.getUuidAndTitleCache();
+	}
+
+	public List<MediaRepresentation> getAllMedia(Taxon taxon, int size, int height, int widthOrDuration, String[] mimeTypes){
+		List<MediaRepresentation> medRep = new ArrayList<MediaRepresentation>();
+		taxon = (Taxon)dao.load(taxon.getUuid());
+		Set<TaxonDescription> descriptions = taxon.getDescriptions();
+		for (TaxonDescription taxDesc: descriptions){
+			Set<DescriptionElementBase> elements = taxDesc.getElements();
+			for (DescriptionElementBase descElem: elements){
+				for(Media media : descElem.getMedia()){
+									
+					//find the best matching representation
+					medRep.add(MediaUtils.findBestMatchingRepresentation(media, size, height, widthOrDuration, mimeTypes));
+					
+				}
+			}
+		}
+		return medRep;
+	}
+
+	public List<TaxonBase> findTaxaByID(Set<Integer> listOfIDs) {
+		return this.dao.findById(listOfIDs);
+	}
+
+	public int countAllRelationships() {
+		return this.dao.countAllRelationships();
+	}
+
+	public List<Synonym> createAllInferredSynonyms(Classification tree,
+			Taxon taxon) {
+		
+		return this.dao.createAllInferredSynonyms(taxon, tree);
+	}
+
+	public List<Synonym> createInferredSynonyms(Classification tree, Taxon taxon, SynonymRelationshipType type) {
+		
+		return this.dao.createInferredSynonyms(taxon, tree, type);
+	}
+
+	public List<TaxonNameBase> findIdenticalTaxonNames(List<String> propertyPath) {
+		
+		return this.dao.findIdenticalTaxonNames(propertyPath);
+	}
+	
+	public List<TaxonNameBase> findIdenticalTaxonNameIds(List<String> propertyPath) {
+		
+		return this.dao.findIdenticalNamesNew(propertyPath);
+	}
+	
+	public String getPhylumName(TaxonNameBase name){
+		return this.dao.getPhylumName(name);
+	}
+	
+	private class TaxonAndNameComparator implements Comparator{
+
+		public int compare(Object arg0, Object arg1) {
+			IdentifiableEntity castArg0 = (IdentifiableEntity) arg0;
+			IdentifiableEntity castArg1 = (IdentifiableEntity) arg1;
+			return castArg0.compareTo(castArg1);
+		}
+		
+	}
+
+	public long deleteSynonymRelationships(Synonym syn) {
+		
+		return dao.deleteSynonymRelationships(syn);
+	}
+
+	
+	public List<SynonymRelationship> listSynonymRelationships(
+			TaxonBase taxonBase, SynonymRelationshipType type, Integer pageSize, Integer pageNumber,
+			List<OrderHint> orderHints, List<String> propertyPaths, Direction direction) {
+		Integer numberOfResults = dao.countSynonymRelationships(taxonBase, type, direction);
+		
+		List<SynonymRelationship> results = new ArrayList<SynonymRelationship>();
+		if(numberOfResults > 0) { // no point checking again
+			results = dao.getSynonymRelationships(taxonBase, type, pageSize, pageNumber, orderHints, propertyPaths, direction); 
+		}
+		return results;
+	}
+
+	/* (non-Javadoc)
+	 * @see eu.etaxonomy.cdm.api.service.ITaxonService#matchToTaxon(eu.etaxonomy.cdm.model.name.NonViralName)
+	 */
+	@Override
+	public Taxon findBestMatchingTaxon(String taxonName) {
+		
+		Taxon matchedTaxon = null;
+		try{
+			// 1. search for acceptet taxa
+			List<TaxonBase> taxonList = dao.findByNameTitleCache(Taxon.class, taxonName, null, MatchMode.EXACT, null, 0, null, null);
+			for(IdentifiableEntity taxonBaseCandidate : taxonList){
+				if(taxonBaseCandidate instanceof Taxon){
+					matchedTaxon = (Taxon)taxonBaseCandidate;
+					if(taxonList.size() > 1){
+						logger.info(taxonList.size() + " TaxonBases found, using first accepted Taxon: " + matchedTaxon.getTitleCache());
+						return matchedTaxon;
 					} else {
-						logger.warn("Description of " + commonTaxonName.getName() + " is not an instance of TaxonDescription");
+						logger.info("using accepted Taxon: " + matchedTaxon.getTitleCache());
+						return matchedTaxon;
+					}
+					//TODO extend method: search using treeUUID, using SecUUID, first find accepted then include synonyms until a matching taxon is found 
+				}
+			}
+			
+			// 2. search for synonyms
+			List<TaxonBase> synonymList = dao.findByNameTitleCache(Synonym.class, taxonName, null, MatchMode.EXACT, null, 0, null, null);
+			for(TaxonBase taxonBase : synonymList){
+				if(taxonBase instanceof Synonym){
+					Set<Taxon> acceptetdCandidates = ((Synonym)taxonBase).getAcceptedTaxa();
+					if(!acceptetdCandidates.isEmpty()){
+						matchedTaxon = acceptetdCandidates.iterator().next();
+						if(acceptetdCandidates.size() == 1){
+							logger.info(acceptetdCandidates.size() + " Accepted taxa found for synonym " + taxonBase.getTitleCache() + ", using first one: " + matchedTaxon.getTitleCache());
+							return matchedTaxon;
+						} else {
+							logger.info("using accepted Taxon " +  matchedTaxon.getTitleCache() + "for synonym " + taxonBase.getTitleCache());
+							return matchedTaxon;
+						}
+						//TODO extend method: search using treeUUID, using SecUUID, first find accepted then include synonyms until a matching taxon is found
 					}
 				}
-				numberOfResults += numberCommonNameResults;
-			} 
+			}
+			
+		} catch (Exception e){
+			logger.error(e);
 		}
 		
-		Collections.sort(results);
-		return new DefaultPagerImpl<IdentifiableEntity>
-			(configurator.getPageNumber(), numberOfResults, configurator.getPageSize(), results);
+		return matchedTaxon;
 	}
 
-	public <TYPE extends TaxonBase> Pager<TYPE> list(Class<TYPE> type,
-			Integer pageSize, Integer pageNumber, List<OrderHint> orderHints,
-			List<String> propertyPaths) {
-		// TODO Auto-generated method stub
+	@Override
+	public Synonym findBestMatchingSynonym(String taxonName) {
+		List<TaxonBase> synonymList = dao.findByNameTitleCache(Synonym.class, taxonName, null, MatchMode.EXACT, null, 0, null, null);
+		if(! synonymList.isEmpty()){
+			Synonym result = CdmBase.deproxy(synonymList.iterator().next(), Synonym.class);
+			if(synonymList.size() == 1){
+				logger.info(synonymList.size() + " Synonym found " + result.getTitleCache() );
+				return result;
+			} else {
+				logger.info("Several matching synonyms found. Using first: " +  result.getTitleCache());
+				return result;
+			}
+		}
 		return null;
 	}
 
+	/* (non-Javadoc)
+	 * @see eu.etaxonomy.cdm.api.service.ITaxonService#moveSynonymToAnotherTaxon(eu.etaxonomy.cdm.model.taxon.SynonymRelationship, eu.etaxonomy.cdm.model.taxon.Taxon, eu.etaxonomy.cdm.model.reference.Reference, java.lang.String)
+	 */
+	@Override
+	public Taxon moveSynonymToAnotherTaxon(SynonymRelationship synonymRelation,
+			Taxon toTaxon, SynonymRelationshipType synonymRelationshipType, Reference reference, String referenceDetail) {
+		Taxon fromTaxon = synonymRelation.getAcceptedTaxon();
+		
+		fromTaxon.removeSynonymRelation(synonymRelation);
+		
+		toTaxon.addSynonym(synonymRelation.getSynonym(), synonymRelationshipType);
+		
+		return toTaxon;
+	}
+	
+	
 }