+// $Id$\r
/**\r
* Copyright (C) 2007 EDIT\r
* European Distributed Institute of Taxonomy \r
\r
package eu.etaxonomy.cdm.api.service;\r
\r
+import java.util.ArrayList;\r
+import java.util.Comparator;\r
+import java.util.List;\r
+import java.util.Set;\r
+import java.util.UUID;\r
+\r
import org.apache.log4j.Logger;\r
import org.springframework.beans.factory.annotation.Autowired;\r
import org.springframework.stereotype.Service;\r
-import org.springframework.transaction.TransactionStatus;\r
+import org.springframework.transaction.annotation.Propagation;\r
import org.springframework.transaction.annotation.Transactional;\r
\r
+import eu.etaxonomy.cdm.api.service.config.ITaxonServiceConfigurator;\r
+import eu.etaxonomy.cdm.api.service.pager.Pager;\r
+import eu.etaxonomy.cdm.api.service.pager.impl.DefaultPagerImpl;\r
+import eu.etaxonomy.cdm.common.IProgressMonitor;\r
+import eu.etaxonomy.cdm.model.common.CdmBase;\r
+import eu.etaxonomy.cdm.model.common.IdentifiableEntity;\r
+import eu.etaxonomy.cdm.model.common.OrderedTermVocabulary;\r
import eu.etaxonomy.cdm.model.common.RelationshipBase;\r
+import eu.etaxonomy.cdm.model.common.RelationshipBase.Direction;\r
+import eu.etaxonomy.cdm.model.common.UuidAndTitleCache;\r
+import eu.etaxonomy.cdm.model.description.DescriptionElementBase;\r
import eu.etaxonomy.cdm.model.description.TaxonDescription;\r
+import eu.etaxonomy.cdm.model.media.Media;\r
+import eu.etaxonomy.cdm.model.media.MediaRepresentation;\r
+import eu.etaxonomy.cdm.model.media.MediaUtils;\r
+import eu.etaxonomy.cdm.model.name.HomotypicalGroup;\r
+import eu.etaxonomy.cdm.model.name.Rank;\r
import eu.etaxonomy.cdm.model.name.TaxonNameBase;\r
-import eu.etaxonomy.cdm.model.reference.ReferenceBase;\r
+import eu.etaxonomy.cdm.model.reference.Reference;\r
+import eu.etaxonomy.cdm.model.taxon.Classification;\r
import eu.etaxonomy.cdm.model.taxon.Synonym;\r
import eu.etaxonomy.cdm.model.taxon.SynonymRelationship;\r
import eu.etaxonomy.cdm.model.taxon.SynonymRelationshipType;\r
import eu.etaxonomy.cdm.model.taxon.TaxonBase;\r
import eu.etaxonomy.cdm.model.taxon.TaxonRelationship;\r
import eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType;\r
+import eu.etaxonomy.cdm.persistence.dao.common.IOrderedTermVocabularyDao;\r
+import eu.etaxonomy.cdm.persistence.dao.description.IDescriptionDao;\r
+import eu.etaxonomy.cdm.persistence.dao.name.ITaxonNameDao;\r
import eu.etaxonomy.cdm.persistence.dao.taxon.ITaxonDao;\r
import eu.etaxonomy.cdm.persistence.fetch.CdmFetch;\r
-\r
-import java.util.Collection;\r
-import java.util.HashSet;\r
-import java.util.List;\r
-import java.util.Map;\r
-import java.util.Set;\r
-import java.util.UUID;\r
+import eu.etaxonomy.cdm.persistence.query.MatchMode;\r
+import eu.etaxonomy.cdm.persistence.query.OrderHint;\r
+import eu.etaxonomy.cdm.strategy.cache.common.IIdentifiableEntityCacheStrategy;\r
\r
\r
+/**\r
+ * @author a.kohlbecker\r
+ * @date 10.09.2010\r
+ *\r
+ */\r
@Service\r
-@Transactional(readOnly = true)\r
-public class TaxonServiceImpl extends ServiceBase<TaxonBase> implements ITaxonService {\r
- static Logger logger = Logger.getLogger(TaxonServiceImpl.class);\r
- \r
- private ITaxonDao taxonDao;\r
+@Transactional(propagation = Propagation.SUPPORTS, readOnly = true)\r
+public class TaxonServiceImpl extends IdentifiableServiceBase<TaxonBase,ITaxonDao> implements ITaxonService{\r
+ private static final Logger logger = Logger.getLogger(TaxonServiceImpl.class);\r
+\r
+ @Autowired\r
+ private ITaxonNameDao nameDao;\r
\r
+ @Autowired \r
+ private IDescriptionDao descriptionDao;\r
+\r
@Autowired\r
- protected void setDao(ITaxonDao dao) {\r
- this.dao = dao;\r
- this.taxonDao = dao;\r
+ private IOrderedTermVocabularyDao orderedVocabularyDao;\r
+ \r
+ /**\r
+ * Constructor\r
+ */\r
+ public TaxonServiceImpl(){\r
+ if (logger.isDebugEnabled()) { logger.debug("Load TaxonService Bean"); }\r
}\r
\r
- public TaxonBase getTaxonByUuid(UUID uuid) {\r
- return super.getCdmObjectByUuid(uuid); \r
+ /**\r
+ * FIXME Candidate for harmonization\r
+ * rename searchByName ? \r
+ */\r
+ public List<TaxonBase> searchTaxaByName(String name, Reference sec) {\r
+ return dao.getTaxaByName(name, sec);\r
+ }\r
+ \r
+ /**\r
+ * FIXME Candidate for harmonization\r
+ * list(Synonym.class, ...)\r
+ * (non-Javadoc)\r
+ * @see eu.etaxonomy.cdm.api.service.ITaxonService#getAllSynonyms(int, int)\r
+ */\r
+ public List<Synonym> getAllSynonyms(int limit, int start) {\r
+ return dao.getAllSynonyms(limit, start);\r
+ }\r
+ \r
+ /**\r
+ * FIXME Candidate for harmonization\r
+ * list(Taxon.class, ...)\r
+ * (non-Javadoc)\r
+ * @see eu.etaxonomy.cdm.api.service.ITaxonService#getAllTaxa(int, int)\r
+ */\r
+ public List<Taxon> getAllTaxa(int limit, int start) {\r
+ return dao.getAllTaxa(limit, start);\r
}\r
\r
- @Transactional(readOnly = false)\r
- public UUID saveTaxon(TaxonBase taxon) {\r
- return super.saveCdmObject(taxon);\r
+\r
+ /**\r
+ * FIXME Candidate for harmonization\r
+ * merge with getRootTaxa(Reference sec, ..., ...)\r
+ * (non-Javadoc)\r
+ * @see eu.etaxonomy.cdm.api.service.ITaxonService#getRootTaxa(eu.etaxonomy.cdm.model.reference.Reference)\r
+ */\r
+ public List<Taxon> getRootTaxa(Reference sec){\r
+ return getRootTaxa(sec, CdmFetch.FETCH_CHILDTAXA(), true);\r
+ }\r
+\r
+ /**\r
+ * FIXME Candidate for harmonization\r
+ * merge with getRootTaxa(Reference sec, ..., ...)\r
+ * (non-Javadoc)\r
+ * @see eu.etaxonomy.cdm.api.service.ITaxonService#getRootTaxa(eu.etaxonomy.cdm.model.reference.Reference, boolean)\r
+ */\r
+ public List<Taxon> getRootTaxa(Reference sec, CdmFetch cdmFetch, boolean onlyWithChildren) {\r
+ if (cdmFetch == null){\r
+ cdmFetch = CdmFetch.NO_FETCH();\r
+ }\r
+ return dao.getRootTaxa(sec, cdmFetch, onlyWithChildren, false);\r
+ }\r
+ \r
+ /**\r
+ * FIXME Candidate for harmonization\r
+ * merge with getRootTaxa(Reference sec, ..., ...)\r
+ * (non-Javadoc)\r
+ * @see eu.etaxonomy.cdm.api.service.ITaxonService#getRootTaxa(eu.etaxonomy.cdm.model.reference.Reference, boolean, boolean)\r
+ */\r
+ public List<Taxon> getRootTaxa(Reference sec, boolean onlyWithChildren,\r
+ boolean withMisapplications) {\r
+ return dao.getRootTaxa(sec, null, onlyWithChildren, withMisapplications);\r
+ }\r
+\r
+ /* (non-Javadoc)\r
+ * @see eu.etaxonomy.cdm.api.service.ITaxonService#getRootTaxa(eu.etaxonomy.cdm.model.name.Rank, eu.etaxonomy.cdm.model.reference.Reference, boolean, boolean)\r
+ */\r
+ public List<Taxon> getRootTaxa(Rank rank, Reference sec, boolean onlyWithChildren,\r
+ boolean withMisapplications, List<String> propertyPaths) {\r
+ return dao.getRootTaxa(rank, sec, null, onlyWithChildren, withMisapplications, propertyPaths);\r
}\r
\r
- //@Transactional(readOnly = false)\r
- public UUID saveTaxon(TaxonBase taxon, TransactionStatus txStatus) {\r
+ /* (non-Javadoc)\r
+ * @see eu.etaxonomy.cdm.api.service.ITaxonService#getAllRelationships(int, int)\r
+ */\r
+ public List<RelationshipBase> getAllRelationships(int limit, int start){\r
+ return dao.getAllRelationships(limit, start);\r
+ }\r
+ \r
+ /**\r
+ * FIXME Candidate for harmonization\r
+ * is this the same as termService.getVocabulary(VocabularyEnum.TaxonRelationshipType) ? \r
+ */\r
+ @Deprecated\r
+ public OrderedTermVocabulary<TaxonRelationshipType> getTaxonRelationshipTypeVocabulary() {\r
\r
- return super.saveCdmObject(taxon);\r
+ String taxonRelTypeVocabularyId = "15db0cf7-7afc-4a86-a7d4-221c73b0c9ac";\r
+ UUID uuid = UUID.fromString(taxonRelTypeVocabularyId);\r
+ OrderedTermVocabulary<TaxonRelationshipType> taxonRelTypeVocabulary = \r
+ (OrderedTermVocabulary)orderedVocabularyDao.findByUuid(uuid);\r
+ return taxonRelTypeVocabulary;\r
}\r
+\r
\r
+\r
+ /*\r
+ * (non-Javadoc)\r
+ * @see eu.etaxonomy.cdm.api.service.ITaxonService#swapSynonymWithAcceptedTaxon(eu.etaxonomy.cdm.model.taxon.Synonym)\r
+ */\r
+ @Transactional(readOnly = false)\r
+ public void swapSynonymAndAcceptedTaxon(Synonym synonym, Taxon acceptedTaxon){\r
+ \r
+ TaxonNameBase synonymName = synonym.getName();\r
+ synonymName.removeTaxonBase(synonym);\r
+ TaxonNameBase taxonName = acceptedTaxon.getName();\r
+ taxonName.removeTaxonBase(acceptedTaxon);\r
+ \r
+ synonym.setName(taxonName);\r
+ acceptedTaxon.setName(synonymName);\r
+ \r
+ // the accepted taxon needs a new uuid because the concept has changed\r
+ // FIXME this leads to an error "HibernateException: immutable natural identifier of an instance of eu.etaxonomy.cdm.model.taxon.Taxon was altered"\r
+ //acceptedTaxon.setUuid(UUID.randomUUID());\r
+ }\r
+ \r
\r
+ /* (non-Javadoc)\r
+ * @see eu.etaxonomy.cdm.api.service.ITaxonService#changeSynonymToAcceptedTaxon(eu.etaxonomy.cdm.model.taxon.Synonym, eu.etaxonomy.cdm.model.taxon.Taxon)\r
+ */\r
+ //TODO correct delete handling still needs to be implemented / checked\r
+ @Override\r
@Transactional(readOnly = false)\r
- public Map<UUID, ? extends TaxonBase> saveTaxonAll(Collection<? extends TaxonBase> taxonCollection){\r
- return saveCdmObjectAll(taxonCollection);\r
+ public Taxon changeSynonymToAcceptedTaxon(Synonym synonym, Taxon acceptedTaxon, boolean deleteSynonym, boolean copyCitationInfo, Reference citation, String microCitation) throws IllegalArgumentException{\r
+ \r
+ TaxonNameBase acceptedName = acceptedTaxon.getName();\r
+ TaxonNameBase synonymName = synonym.getName();\r
+ HomotypicalGroup synonymHomotypicGroup = synonymName.getHomotypicalGroup();\r
+ if (acceptedName.getHomotypicalGroup().equals(synonymHomotypicGroup)){\r
+ String message = "The accepted taxon and the synonym are part of the same homotypical group and therefore can not be both accepted.";\r
+ throw new IllegalArgumentException(message);\r
+ }\r
+ \r
+ Taxon newAcceptedTaxon = Taxon.NewInstance(synonym.getName(), acceptedTaxon.getSec());\r
+ \r
+ SynonymRelationshipType relType = SynonymRelationshipType.HOMOTYPIC_SYNONYM_OF();\r
+ List<Synonym> heteroSynonyms = synonymHomotypicGroup.getSynonymsInGroup(acceptedTaxon.getSec());\r
+ for (Synonym heteroSynonym : heteroSynonyms){\r
+ if (synonym.equals(heteroSynonym)){\r
+ acceptedTaxon.removeSynonym(heteroSynonym, false);\r
+ }else{\r
+ heteroSynonym.replaceAcceptedTaxon(newAcceptedTaxon, relType, copyCitationInfo, citation, microCitation);\r
+ }\r
+ }\r
+ \r
+// synonym.getName().removeTaxonBase(synonym);\r
+ //TODO correct delete handling still needs to be implemented / checked\r
+ if (deleteSynonym){\r
+ try {\r
+ this.delete(synonym);\r
+ } catch (Exception e) {\r
+ logger.info("Can't delete old synonym from database");\r
+ }\r
+ }\r
+ \r
+ \r
+ return newAcceptedTaxon;\r
}\r
-\r
+ \r
+ public Taxon changeSynonymToRelatedTaxon(Synonym synonym, Taxon toTaxon, TaxonRelationshipType taxonRelationshipType, Reference citation, String microcitation){\r
+ \r
+ // Get name from synonym\r
+ TaxonNameBase<?, ?> synonymName = synonym.getName();\r
+ \r
+ // remove synonym from taxon\r
+ toTaxon.removeSynonym(synonym);\r
+ \r
+ // Create a taxon with synonym name\r
+ Taxon fromTaxon = Taxon.NewInstance(synonymName, null);\r
+ \r
+ // Add taxon relation \r
+ fromTaxon.addTaxonRelation(toTaxon, taxonRelationshipType, citation, microcitation);\r
+ \r
+ // since we are swapping names, we have to detach the name from the synonym completely. \r
+ // Otherwise the synonym will still be in the list of typified names.\r
+ synonym.getName().removeTaxonBase(synonym);\r
+ \r
+ return fromTaxon;\r
+ }\r
+ \r
+ /* (non-Javadoc)\r
+ * @see eu.etaxonomy.cdm.api.service.ITaxonService#changeHomotypicalGroupOfSynonym(eu.etaxonomy.cdm.model.taxon.Synonym, eu.etaxonomy.cdm.model.name.HomotypicalGroup, eu.etaxonomy.cdm.model.taxon.Taxon, boolean, boolean)\r
+ */\r
@Transactional(readOnly = false)\r
- public UUID removeTaxon(TaxonBase taxon) {\r
- return super.removeCdmObject(taxon);\r
+ @Override\r
+ public void changeHomotypicalGroupOfSynonym(Synonym synonym, HomotypicalGroup newHomotypicalGroup, Taxon targetTaxon, \r
+ boolean removeFromOtherTaxa, boolean setBasionymRelationIfApplicable){\r
+ // Get synonym name\r
+ TaxonNameBase synonymName = synonym.getName();\r
+ HomotypicalGroup oldHomotypicalGroup = synonymName.getHomotypicalGroup();\r
+ \r
+ \r
+ // Switch groups\r
+ oldHomotypicalGroup.removeTypifiedName(synonymName);\r
+ newHomotypicalGroup.addTypifiedName(synonymName);\r
+ \r
+ //remove existing basionym relationships\r
+ synonymName.removeBasionyms();\r
+ \r
+ //add basionym relationship\r
+ if (setBasionymRelationIfApplicable){\r
+ Set<TaxonNameBase> basionyms = newHomotypicalGroup.getBasionyms();\r
+ for (TaxonNameBase basionym : basionyms){\r
+ synonymName.addBasionym(basionym);\r
+ }\r
+ }\r
+\r
+ //set synonym relationship correctly\r
+// SynonymRelationship relToTaxon = null;\r
+ boolean relToTargetTaxonExists = false;\r
+ Set<SynonymRelationship> existingRelations = synonym.getSynonymRelations();\r
+ for (SynonymRelationship rel : existingRelations){\r
+ Taxon acceptedTaxon = rel.getAcceptedTaxon();\r
+ boolean isTargetTaxon = acceptedTaxon != null && acceptedTaxon.equals(targetTaxon);\r
+ HomotypicalGroup acceptedGroup = acceptedTaxon.getHomotypicGroup();\r
+ boolean isHomotypicToTaxon = acceptedGroup.equals(newHomotypicalGroup);\r
+ SynonymRelationshipType newRelationType = isHomotypicToTaxon? SynonymRelationshipType.HOMOTYPIC_SYNONYM_OF() : SynonymRelationshipType.HETEROTYPIC_SYNONYM_OF();\r
+ rel.setType(newRelationType);\r
+ //TODO handle citation and microCitation\r
+ \r
+ if (isTargetTaxon){\r
+ relToTargetTaxonExists = true;\r
+ }else{\r
+ if (removeFromOtherTaxa){\r
+ acceptedTaxon.removeSynonym(synonym, false);\r
+ }else{\r
+ //do nothing\r
+ }\r
+ }\r
+ }\r
+ if (targetTaxon != null && ! relToTargetTaxonExists ){\r
+ Taxon acceptedTaxon = targetTaxon;\r
+ HomotypicalGroup acceptedGroup = acceptedTaxon.getHomotypicGroup();\r
+ boolean isHomotypicToTaxon = acceptedGroup.equals(newHomotypicalGroup);\r
+ SynonymRelationshipType relType = isHomotypicToTaxon? SynonymRelationshipType.HOMOTYPIC_SYNONYM_OF() : SynonymRelationshipType.HETEROTYPIC_SYNONYM_OF();\r
+ //TODO handle citation and microCitation\r
+ Reference citation = null;\r
+ String microCitation = null;\r
+ acceptedTaxon.addSynonym(synonym, relType, citation, microCitation);\r
+ }\r
+\r
}\r
+ \r
\r
- public List<TaxonBase> searchTaxaByName(String name, ReferenceBase sec) {\r
- return taxonDao.getTaxaByName(name, sec);\r
+ /* (non-Javadoc)\r
+ * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#updateTitleCache(java.lang.Integer, eu.etaxonomy.cdm.strategy.cache.common.IIdentifiableEntityCacheStrategy)\r
+ */\r
+ @Override\r
+ public void updateTitleCache(Class<? extends TaxonBase> clazz, Integer stepSize, IIdentifiableEntityCacheStrategy<TaxonBase> cacheStrategy, IProgressMonitor monitor) {\r
+ if (clazz == null){\r
+ clazz = TaxonBase.class;\r
+ }\r
+ super.updateTitleCacheImpl(clazz, stepSize, cacheStrategy, monitor);\r
}\r
\r
- public List<TaxonBase> getAllTaxonBases(int limit, int start){\r
- return taxonDao.list(limit, start);\r
+ @Autowired\r
+ protected void setDao(ITaxonDao dao) {\r
+ this.dao = dao;\r
+ }\r
+\r
+ /* (non-Javadoc)\r
+ * @see eu.etaxonomy.cdm.api.service.ITaxonService#findTaxaByName(java.lang.Class, java.lang.String, java.lang.String, java.lang.String, java.lang.String, eu.etaxonomy.cdm.model.name.Rank, java.lang.Integer, java.lang.Integer)\r
+ */\r
+ public Pager<TaxonBase> findTaxaByName(Class<? extends TaxonBase> clazz, String uninomial, String infragenericEpithet, String specificEpithet, String infraspecificEpithet, Rank rank, Integer pageSize,Integer pageNumber) {\r
+ Integer numberOfResults = dao.countTaxaByName(clazz, uninomial, infragenericEpithet, specificEpithet, infraspecificEpithet, rank);\r
+ \r
+ List<TaxonBase> results = new ArrayList<TaxonBase>();\r
+ if(numberOfResults > 0) { // no point checking again\r
+ results = dao.findTaxaByName(clazz, uninomial, infragenericEpithet, specificEpithet, infraspecificEpithet, rank, pageSize, pageNumber); \r
+ }\r
+ \r
+ return new DefaultPagerImpl<TaxonBase>(pageNumber, numberOfResults, pageSize, results);\r
+ }\r
+\r
+ /* (non-Javadoc)\r
+ * @see eu.etaxonomy.cdm.api.service.ITaxonService#listTaxaByName(java.lang.Class, java.lang.String, java.lang.String, java.lang.String, java.lang.String, eu.etaxonomy.cdm.model.name.Rank, java.lang.Integer, java.lang.Integer)\r
+ */\r
+ public List<TaxonBase> listTaxaByName(Class<? extends TaxonBase> clazz, String uninomial, String infragenericEpithet, String specificEpithet, String infraspecificEpithet, Rank rank, Integer pageSize,Integer pageNumber) {\r
+ Integer numberOfResults = dao.countTaxaByName(clazz, uninomial, infragenericEpithet, specificEpithet, infraspecificEpithet, rank);\r
+ \r
+ List<TaxonBase> results = new ArrayList<TaxonBase>();\r
+ if(numberOfResults > 0) { // no point checking again\r
+ results = dao.findTaxaByName(clazz, uninomial, infragenericEpithet, specificEpithet, infraspecificEpithet, rank, pageSize, pageNumber); \r
+ }\r
+ \r
+ return results;\r
}\r
\r
- public List<Taxon> getAllTaxa(int limit, int start){\r
- return taxonDao.getAllTaxa_(limit, start);\r
+ /* (non-Javadoc)\r
+ * @see eu.etaxonomy.cdm.api.service.ITaxonService#listToTaxonRelationships(eu.etaxonomy.cdm.model.taxon.Taxon, eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List)\r
+ */\r
+ public List<TaxonRelationship> listToTaxonRelationships(Taxon taxon, TaxonRelationshipType type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths){\r
+ Integer numberOfResults = dao.countTaxonRelationships(taxon, type, TaxonRelationship.Direction.relatedTo);\r
+ \r
+ List<TaxonRelationship> results = new ArrayList<TaxonRelationship>();\r
+ if(numberOfResults > 0) { // no point checking again\r
+ results = dao.getTaxonRelationships(taxon, type, pageSize, pageNumber, orderHints, propertyPaths, TaxonRelationship.Direction.relatedTo); \r
+ }\r
+ return results;\r
}\r
\r
- public List<Synonym> getAllSynonyms(int limit, int start) {\r
- return taxonDao.getAllSynonyms(limit, start);\r
+ /* (non-Javadoc)\r
+ * @see eu.etaxonomy.cdm.api.service.ITaxonService#pageToTaxonRelationships(eu.etaxonomy.cdm.model.taxon.Taxon, eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List)\r
+ */\r
+ public Pager<TaxonRelationship> pageToTaxonRelationships(Taxon taxon, TaxonRelationshipType type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {\r
+ Integer numberOfResults = dao.countTaxonRelationships(taxon, type, TaxonRelationship.Direction.relatedTo);\r
+ \r
+ List<TaxonRelationship> results = new ArrayList<TaxonRelationship>();\r
+ if(numberOfResults > 0) { // no point checking again\r
+ results = dao.getTaxonRelationships(taxon, type, pageSize, pageNumber, orderHints, propertyPaths, TaxonRelationship.Direction.relatedTo); \r
+ }\r
+ return new DefaultPagerImpl<TaxonRelationship>(pageNumber, numberOfResults, pageSize, results);\r
}\r
\r
/* (non-Javadoc)\r
- * @see eu.etaxonomy.cdm.api.service.ITaxonService#getRootTaxa(eu.etaxonomy.cdm.model.reference.ReferenceBase)\r
+ * @see eu.etaxonomy.cdm.api.service.ITaxonService#listFromTaxonRelationships(eu.etaxonomy.cdm.model.taxon.Taxon, eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List)\r
*/\r
- public List<Taxon> getRootTaxa(ReferenceBase sec){\r
- return getRootTaxa(sec, CdmFetch.FETCH_CHILDTAXA(), true);\r
+ public List<TaxonRelationship> listFromTaxonRelationships(Taxon taxon, TaxonRelationshipType type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths){\r
+ Integer numberOfResults = dao.countTaxonRelationships(taxon, type, TaxonRelationship.Direction.relatedFrom);\r
+ \r
+ List<TaxonRelationship> results = new ArrayList<TaxonRelationship>();\r
+ if(numberOfResults > 0) { // no point checking again\r
+ results = dao.getTaxonRelationships(taxon, type, pageSize, pageNumber, orderHints, propertyPaths, TaxonRelationship.Direction.relatedFrom); \r
+ }\r
+ return results;\r
}\r
-\r
+ \r
/* (non-Javadoc)\r
- * @see eu.etaxonomy.cdm.api.service.ITaxonService#getRootTaxa(eu.etaxonomy.cdm.model.reference.ReferenceBase, boolean)\r
+ * @see eu.etaxonomy.cdm.api.service.ITaxonService#pageFromTaxonRelationships(eu.etaxonomy.cdm.model.taxon.Taxon, eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List)\r
*/\r
- public List<Taxon> getRootTaxa(ReferenceBase sec, CdmFetch cdmFetch, boolean onlyWithChildren) {\r
- if (cdmFetch == null){\r
- cdmFetch = CdmFetch.NO_FETCH();\r
+ public Pager<TaxonRelationship> pageFromTaxonRelationships(Taxon taxon, TaxonRelationshipType type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {\r
+ Integer numberOfResults = dao.countTaxonRelationships(taxon, type, TaxonRelationship.Direction.relatedFrom);\r
+ \r
+ List<TaxonRelationship> results = new ArrayList<TaxonRelationship>();\r
+ if(numberOfResults > 0) { // no point checking again\r
+ results = dao.getTaxonRelationships(taxon, type, pageSize, pageNumber, orderHints, propertyPaths, TaxonRelationship.Direction.relatedFrom); \r
}\r
- return taxonDao.getRootTaxa(sec, cdmFetch, onlyWithChildren);\r
+ return new DefaultPagerImpl<TaxonRelationship>(pageNumber, numberOfResults, pageSize, results);\r
}\r
\r
- public List<RelationshipBase> getAllRelationships(int limit, int start){\r
- return taxonDao.getAllRelationships(limit, start);\r
+ /* (non-Javadoc)\r
+ * @see eu.etaxonomy.cdm.api.service.ITaxonService#getSynonyms(eu.etaxonomy.cdm.model.taxon.Taxon, eu.etaxonomy.cdm.model.taxon.SynonymRelationshipType, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List)\r
+ */\r
+ public Pager<SynonymRelationship> getSynonyms(Taxon taxon, SynonymRelationshipType type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {\r
+ Integer numberOfResults = dao.countSynonyms(taxon, type);\r
+ \r
+ List<SynonymRelationship> results = new ArrayList<SynonymRelationship>();\r
+ if(numberOfResults > 0) { // no point checking again\r
+ results = dao.getSynonyms(taxon, type, pageSize, pageNumber, orderHints, propertyPaths); \r
+ }\r
+ \r
+ return new DefaultPagerImpl<SynonymRelationship>(pageNumber, numberOfResults, pageSize, results);\r
}\r
\r
/* (non-Javadoc)\r
- * @see eu.etaxonomy.cdm.api.service.ITaxonService#makeTaxonSynonym(eu.etaxonomy.cdm.model.taxon.Taxon, eu.etaxonomy.cdm.model.taxon.Taxon)\r
+ * @see eu.etaxonomy.cdm.api.service.ITaxonService#getSynonyms(eu.etaxonomy.cdm.model.taxon.Synonym, eu.etaxonomy.cdm.model.taxon.SynonymRelationshipType, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List)\r
*/\r
- @Transactional(readOnly = false)\r
- public Synonym makeTaxonSynonym(Taxon oldTaxon, Taxon newAcceptedTaxon, SynonymRelationshipType synonymType, ReferenceBase citation, String citationMicroReference) {\r
- if (oldTaxon == null || newAcceptedTaxon == null || oldTaxon.getName() == null){\r
- return null;\r
+ public Pager<SynonymRelationship> getSynonyms(Synonym synonym, SynonymRelationshipType type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {\r
+ Integer numberOfResults = dao.countSynonyms(synonym, type);\r
+ \r
+ List<SynonymRelationship> results = new ArrayList<SynonymRelationship>();\r
+ if(numberOfResults > 0) { // no point checking again\r
+ results = dao.getSynonyms(synonym, type, pageSize, pageNumber, orderHints, propertyPaths); \r
}\r
\r
- // Move oldTaxon to newTaxon\r
- TaxonNameBase synonymName = oldTaxon.getName();\r
- if (synonymType == null){\r
- if (synonymName.isHomotypic(newAcceptedTaxon.getName())){\r
- synonymType = SynonymRelationshipType.HOMOTYPIC_SYNONYM_OF();\r
- }else{\r
- //TODO synonymType \r
- synonymType = SynonymRelationshipType.HETEROTYPIC_SYNONYM_OF();\r
+ return new DefaultPagerImpl<SynonymRelationship>(pageNumber, numberOfResults, pageSize, results);\r
+ }\r
+ \r
+ /* (non-Javadoc)\r
+ * @see eu.etaxonomy.cdm.api.service.ITaxonService#getHomotypicSynonymsByHomotypicGroup(eu.etaxonomy.cdm.model.taxon.Taxon, java.util.List)\r
+ */\r
+ public List<Synonym> getHomotypicSynonymsByHomotypicGroup(Taxon taxon, List<String> propertyPaths){\r
+ Taxon t = (Taxon)dao.load(taxon.getUuid(), propertyPaths);\r
+ return t.getHomotypicSynonymsByHomotypicGroup();\r
+ }\r
+ \r
+ /* (non-Javadoc)\r
+ * @see eu.etaxonomy.cdm.api.service.ITaxonService#getHeterotypicSynonymyGroups(eu.etaxonomy.cdm.model.taxon.Taxon, java.util.List)\r
+ */\r
+ public List<List<Synonym>> getHeterotypicSynonymyGroups(Taxon taxon, List<String> propertyPaths){\r
+ Taxon t = (Taxon)dao.load(taxon.getUuid(), propertyPaths);\r
+ List<HomotypicalGroup> hsgl = t.getHeterotypicSynonymyGroups();\r
+ List<List<Synonym>> heterotypicSynonymyGroups = new ArrayList<List<Synonym>>(hsgl.size());\r
+ for(HomotypicalGroup hsg : hsgl){\r
+ heterotypicSynonymyGroups.add(hsg.getSynonymsInGroup(t.getSec()));\r
+ }\r
+ return heterotypicSynonymyGroups;\r
+ }\r
+ \r
+ public List<UuidAndTitleCache<TaxonBase>> findTaxaAndNamesForEditor(ITaxonServiceConfigurator configurator){\r
+ \r
+ List<UuidAndTitleCache<TaxonBase>> result = new ArrayList<UuidAndTitleCache<TaxonBase>>();\r
+ Class<? extends TaxonBase> clazz = null;\r
+ if ((configurator.isDoTaxa() && configurator.isDoSynonyms())) {\r
+ clazz = TaxonBase.class;\r
+ //propertyPath.addAll(configurator.getTaxonPropertyPath());\r
+ //propertyPath.addAll(configurator.getSynonymPropertyPath());\r
+ } else if(configurator.isDoTaxa()) {\r
+ clazz = Taxon.class;\r
+ //propertyPath = configurator.getTaxonPropertyPath();\r
+ } else if (configurator.isDoSynonyms()) {\r
+ clazz = Synonym.class;\r
+ //propertyPath = configurator.getSynonymPropertyPath();\r
+ }\r
+ \r
+ \r
+ result = dao.getTaxaByNameForEditor(clazz, configurator.getSearchString(), configurator.getClassification(), configurator.getMatchMode(), configurator.getNamedAreas());\r
+ return result;\r
+ }\r
+ /* (non-Javadoc)\r
+ * @see eu.etaxonomy.cdm.api.service.ITaxonService#findTaxaAndNames(eu.etaxonomy.cdm.api.service.config.ITaxonServiceConfigurator)\r
+ */\r
+ public Pager<IdentifiableEntity> findTaxaAndNames(ITaxonServiceConfigurator configurator) {\r
+ \r
+ List<IdentifiableEntity> results = new ArrayList<IdentifiableEntity>();\r
+ int numberOfResults = 0; // overall number of results (as opposed to number of results per page)\r
+ List<TaxonBase> taxa = null; \r
+\r
+ // Taxa and synonyms\r
+ long numberTaxaResults = 0L;\r
+ \r
+ Class<? extends TaxonBase> clazz = null;\r
+ List<String> propertyPath = new ArrayList<String>();\r
+ if(configurator.getTaxonPropertyPath() != null){\r
+ propertyPath.addAll(configurator.getTaxonPropertyPath());\r
+ }\r
+ if ((configurator.isDoTaxa() && configurator.isDoSynonyms())) {\r
+ clazz = TaxonBase.class;\r
+ //propertyPath.addAll(configurator.getTaxonPropertyPath());\r
+ //propertyPath.addAll(configurator.getSynonymPropertyPath());\r
+ } else if(configurator.isDoTaxa()) {\r
+ clazz = Taxon.class;\r
+ //propertyPath = configurator.getTaxonPropertyPath();\r
+ } else if (configurator.isDoSynonyms()) {\r
+ clazz = Synonym.class;\r
+ //propertyPath = configurator.getSynonymPropertyPath();\r
+ }\r
+ \r
+ if(clazz != null){\r
+ if(configurator.getPageSize() != null){ // no point counting if we need all anyway\r
+ numberTaxaResults = \r
+ dao.countTaxaByName(clazz, \r
+ configurator.getSearchString(), configurator.getClassification(), configurator.getMatchMode(),\r
+ configurator.getNamedAreas());\r
+ }\r
+ \r
+ if(configurator.getPageSize() == null || numberTaxaResults > configurator.getPageSize() * configurator.getPageNumber()){ // no point checking again if less results\r
+ taxa = dao.getTaxaByName(clazz, \r
+ configurator.getSearchString(), configurator.getClassification(), configurator.getMatchMode(),\r
+ configurator.getNamedAreas(), configurator.getPageSize(), \r
+ configurator.getPageNumber(), propertyPath);\r
}\r
}\r
- SynonymRelationship synRel = newAcceptedTaxon.addSynonymName(synonymName, synonymType, citation, citationMicroReference);\r
- \r
- //Move Synonym Relations to new Taxon\r
- for(SynonymRelationship synRelation : oldTaxon.getSynonymRelations()){\r
- newAcceptedTaxon.addSynonym(synRelation.getSynonym(), synRelation.getType(), \r
- synRelation.getCitation(), synRelation.getCitationMicroReference());\r
- }\r
-\r
- //Move Taxon RelationShips to new Taxon\r
- Set<TaxonRelationship> removableTaxonRels = new HashSet<TaxonRelationship>();\r
- for(TaxonRelationship taxonRelation : oldTaxon.getTaxonRelations()){\r
- //CHILDREN\r
- if (taxonRelation.getType().equals(TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN())){\r
- if (taxonRelation.getFromTaxon() == oldTaxon){\r
- removableTaxonRels.add(taxonRelation);\r
-// oldTaxon.removeTaxonRelation(taxonRelation);\r
- }else if(taxonRelation.getToTaxon() == oldTaxon){\r
- newAcceptedTaxon.addTaxonomicChild(taxonRelation.getFromTaxon(), taxonRelation.getCitation(), taxonRelation.getCitationMicroReference());\r
- removableTaxonRels.add(taxonRelation);\r
-// oldTaxon.removeTaxonRelation(taxonRelation);\r
- }else{\r
- logger.warn("Taxon is not part of its own Taxonrelationship");\r
+\r
+ if (logger.isDebugEnabled()) { logger.debug(numberTaxaResults + " matching taxa counted"); }\r
+ \r
+ if(taxa != null){\r
+ results.addAll(taxa);\r
+ }\r
+ \r
+ numberOfResults += numberTaxaResults;\r
+\r
+ // Names without taxa \r
+ if (configurator.isDoNamesWithoutTaxa()) {\r
+ int numberNameResults = 0;\r
+ \r
+ List<? extends TaxonNameBase<?,?>> names = \r
+ nameDao.findByName(configurator.getSearchString(), configurator.getMatchMode(), \r
+ configurator.getPageSize(), configurator.getPageNumber(), null, configurator.getTaxonNamePropertyPath());\r
+ if (logger.isDebugEnabled()) { logger.debug(names.size() + " matching name(s) found"); }\r
+ if (names.size() > 0) {\r
+ for (TaxonNameBase<?,?> taxonName : names) {\r
+ if (taxonName.getTaxonBases().size() == 0) {\r
+ results.add(taxonName);\r
+ numberNameResults++;\r
+ }\r
}\r
+ if (logger.isDebugEnabled()) { logger.debug(numberNameResults + " matching name(s) without taxa found"); }\r
+ numberOfResults += numberNameResults;\r
}\r
- //MISAPPLIED NAMES\r
- if (taxonRelation.getType().equals(TaxonRelationshipType.MISAPPLIED_NAME_FOR())){\r
- if (taxonRelation.getFromTaxon() == oldTaxon){\r
- newAcceptedTaxon.addMisappliedName(taxonRelation.getToTaxon(), taxonRelation.getCitation(), taxonRelation.getCitationMicroReference());\r
- removableTaxonRels.add(taxonRelation);\r
-// oldTaxon.removeTaxonRelation(taxonRelation);\r
- }else if(taxonRelation.getToTaxon() == oldTaxon){\r
- newAcceptedTaxon.addMisappliedName(taxonRelation.getFromTaxon(), taxonRelation.getCitation(), taxonRelation.getCitationMicroReference());\r
- removableTaxonRels.add(taxonRelation);\r
-// oldTaxon.removeTaxonRelation(taxonRelation);\r
- }else{\r
- logger.warn("Taxon is not part of its own Taxonrelationship");\r
- }\r
+ }\r
+ \r
+ // Taxa from common names\r
+ \r
+ if (configurator.isDoTaxaByCommonNames()) {\r
+ taxa = null;\r
+ numberTaxaResults = 0;\r
+ if(configurator.getPageSize() != null){// no point counting if we need all anyway\r
+ numberTaxaResults = dao.countTaxaByCommonName(configurator.getSearchString(), configurator.getClassification(), configurator.getMatchMode(), configurator.getNamedAreas());\r
+ }\r
+ if(configurator.getPageSize() == null || numberTaxaResults > configurator.getPageSize() * configurator.getPageNumber()){\r
+ taxa = dao.getTaxaByCommonName(configurator.getSearchString(), configurator.getClassification(), configurator.getMatchMode(), configurator.getNamedAreas(), configurator.getPageSize(), configurator.getPageNumber(), configurator.getTaxonPropertyPath());\r
}\r
- //Concept Relationships\r
- //FIXME implement\r
-// if (taxonRelation.getType().equals(TaxonRelationshipType.MISAPPLIEDNAMEFOR())){\r
-// if (taxonRelation.getFromTaxon() == oldTaxon){\r
-// newAcceptedTaxon.addMisappliedName(taxonRelation.getToTaxon(), taxonRelation.getCitation(), taxonRelation.getCitationMicroReference());\r
-// removableTaxonRels.add(taxonRelation);\r
-// }else if(taxonRelation.getToTaxon() == oldTaxon){\r
-// newAcceptedTaxon.addMisappliedName(taxonRelation.getFromTaxon(), taxonRelation.getCitation(), taxonRelation.getCitationMicroReference());\r
-// removableTaxonRels.add(taxonRelation);\r
-// }else{\r
-// logger.warn("Taxon is not part of its own Taxonrelationship");\r
-// }\r
-// }\r
+ if(taxa != null){\r
+ results.addAll(taxa);\r
+ }\r
+ numberOfResults += numberTaxaResults;\r
+ \r
}\r
\r
- for(TaxonRelationship taxonRel : removableTaxonRels) {\r
- oldTaxon.removeTaxonRelation(taxonRel);\r
+ return new DefaultPagerImpl<IdentifiableEntity>\r
+ (configurator.getPageNumber(), numberOfResults, configurator.getPageSize(), results);\r
+ }\r
+ \r
+ public List<UuidAndTitleCache<TaxonBase>> getTaxonUuidAndTitleCache(){\r
+ return dao.getUuidAndTitleCache();\r
+ }\r
+\r
+ /* (non-Javadoc)\r
+ * @see eu.etaxonomy.cdm.api.service.ITaxonService#getAllMedia(eu.etaxonomy.cdm.model.taxon.Taxon, int, int, int, java.lang.String[])\r
+ */\r
+ public List<MediaRepresentation> getAllMedia(Taxon taxon, int size, int height, int widthOrDuration, String[] mimeTypes){\r
+ List<MediaRepresentation> medRep = new ArrayList<MediaRepresentation>();\r
+ taxon = (Taxon)dao.load(taxon.getUuid());\r
+ Set<TaxonDescription> descriptions = taxon.getDescriptions();\r
+ for (TaxonDescription taxDesc: descriptions){\r
+ Set<DescriptionElementBase> elements = taxDesc.getElements();\r
+ for (DescriptionElementBase descElem: elements){\r
+ for(Media media : descElem.getMedia()){\r
+ \r
+ //find the best matching representation\r
+ medRep.add(MediaUtils.findBestMatchingRepresentation(media, size, height, widthOrDuration, mimeTypes));\r
+ \r
+ }\r
+ }\r
}\r
+ return medRep;\r
+ }\r
+\r
+ /* (non-Javadoc)\r
+ * @see eu.etaxonomy.cdm.api.service.ITaxonService#findTaxaByID(java.util.Set)\r
+ */\r
+ public List<TaxonBase> findTaxaByID(Set<Integer> listOfIDs) {\r
+ return this.dao.findById(listOfIDs);\r
+ }\r
+\r
+ /* (non-Javadoc)\r
+ * @see eu.etaxonomy.cdm.api.service.ITaxonService#countAllRelationships()\r
+ */\r
+ public int countAllRelationships() {\r
+ return this.dao.countAllRelationships();\r
+ }\r
+\r
+ /* (non-Javadoc)\r
+ * @see eu.etaxonomy.cdm.api.service.ITaxonService#createAllInferredSynonyms(eu.etaxonomy.cdm.model.taxon.Classification, eu.etaxonomy.cdm.model.taxon.Taxon)\r
+ */\r
+ public List<Synonym> createAllInferredSynonyms(Classification tree,\r
+ Taxon taxon) {\r
\r
- //Move Descriptions to new Taxon\r
- for(TaxonDescription taxDescription : oldTaxon.getDescriptions()){\r
- newAcceptedTaxon.addDescription(taxDescription);\r
+ return this.dao.createAllInferredSynonyms(taxon, tree);\r
+ }\r
+\r
+ /* (non-Javadoc)\r
+ * @see eu.etaxonomy.cdm.api.service.ITaxonService#createInferredSynonyms(eu.etaxonomy.cdm.model.taxon.Classification, eu.etaxonomy.cdm.model.taxon.Taxon, eu.etaxonomy.cdm.model.taxon.SynonymRelationshipType)\r
+ */\r
+ public List<Synonym> createInferredSynonyms(Classification tree, Taxon taxon, SynonymRelationshipType type) {\r
+ \r
+ return this.dao.createInferredSynonyms(taxon, tree, type);\r
+ }\r
+\r
+ /* (non-Javadoc)\r
+ * @see eu.etaxonomy.cdm.api.service.ITaxonService#findIdenticalTaxonNames(java.util.List)\r
+ */\r
+ public List<TaxonNameBase> findIdenticalTaxonNames(List<String> propertyPath) {\r
+ \r
+ return this.dao.findIdenticalTaxonNames(propertyPath);\r
+ }\r
+ \r
+ /* (non-Javadoc)\r
+ * @see eu.etaxonomy.cdm.api.service.ITaxonService#findIdenticalTaxonNameIds(java.util.List)\r
+ */\r
+ public List<TaxonNameBase> findIdenticalTaxonNameIds(List<String> propertyPath) {\r
+ \r
+ return this.dao.findIdenticalNamesNew(propertyPath);\r
+ }\r
+ \r
+ /* (non-Javadoc)\r
+ * @see eu.etaxonomy.cdm.api.service.ITaxonService#getPhylumName(eu.etaxonomy.cdm.model.name.TaxonNameBase)\r
+ */\r
+ public String getPhylumName(TaxonNameBase name){\r
+ return this.dao.getPhylumName(name);\r
+ }\r
+ \r
+ private class TaxonAndNameComparator implements Comparator{\r
+\r
+ public int compare(Object arg0, Object arg1) {\r
+ IdentifiableEntity castArg0 = (IdentifiableEntity) arg0;\r
+ IdentifiableEntity castArg1 = (IdentifiableEntity) arg1;\r
+ return castArg0.compareTo(castArg1);\r
}\r
- //delete old Taxon\r
- this.dao.saveOrUpdate(newAcceptedTaxon);\r
-// FIXME implement\r
-// this.dao.delete(oldTaxon);\r
\r
- //return\r
-// this.dao.flush();\r
- return synRel.getSynonym();\r
}\r
\r
+ /* (non-Javadoc)\r
+ * @see eu.etaxonomy.cdm.api.service.ITaxonService#deleteSynonymRelationships(eu.etaxonomy.cdm.model.taxon.Synonym)\r
+ */\r
+ public long deleteSynonymRelationships(Synonym syn) {\r
+ \r
+ return dao.deleteSynonymRelationships(syn);\r
+ }\r
\r
- public void generateTitleCache() {\r
- generateTitleCache(true);\r
+ \r
+ /* (non-Javadoc)\r
+ * @see eu.etaxonomy.cdm.api.service.ITaxonService#listSynonymRelationships(eu.etaxonomy.cdm.model.taxon.TaxonBase, eu.etaxonomy.cdm.model.taxon.SynonymRelationshipType, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List, eu.etaxonomy.cdm.model.common.RelationshipBase.Direction)\r
+ */\r
+ public List<SynonymRelationship> listSynonymRelationships(\r
+ TaxonBase taxonBase, SynonymRelationshipType type, Integer pageSize, Integer pageNumber,\r
+ List<OrderHint> orderHints, List<String> propertyPaths, Direction direction) {\r
+ Integer numberOfResults = dao.countSynonymRelationships(taxonBase, type, direction);\r
+ \r
+ List<SynonymRelationship> results = new ArrayList<SynonymRelationship>();\r
+ if(numberOfResults > 0) { // no point checking again\r
+ results = dao.getSynonymRelationships(taxonBase, type, pageSize, pageNumber, orderHints, propertyPaths, direction); \r
+ }\r
+ return results;\r
+ }\r
+\r
+ /* (non-Javadoc)\r
+ * @see eu.etaxonomy.cdm.api.service.ITaxonService#findBestMatchingTaxon(java.lang.String)\r
+ */\r
+ @Override\r
+ public Taxon findBestMatchingTaxon(String taxonName) {\r
+ \r
+ Taxon matchedTaxon = null;\r
+ try{\r
+ // 1. search for acceptet taxa\r
+ List<TaxonBase> taxonList = dao.findByNameTitleCache(Taxon.class, taxonName, null, MatchMode.EXACT, null, 0, null, null);\r
+ for(IdentifiableEntity taxonBaseCandidate : taxonList){\r
+ if(taxonBaseCandidate instanceof Taxon){\r
+ matchedTaxon = (Taxon)taxonBaseCandidate;\r
+ if(taxonList.size() > 1){\r
+ logger.info(taxonList.size() + " TaxonBases found, using first accepted Taxon: " + matchedTaxon.getTitleCache());\r
+ return matchedTaxon;\r
+ } else {\r
+ logger.info("using accepted Taxon: " + matchedTaxon.getTitleCache());\r
+ return matchedTaxon;\r
+ }\r
+ //TODO extend method: search using treeUUID, using SecUUID, first find accepted then include synonyms until a matching taxon is found \r
+ }\r
+ }\r
+ \r
+ // 2. search for synonyms\r
+ List<TaxonBase> synonymList = dao.findByNameTitleCache(Synonym.class, taxonName, null, MatchMode.EXACT, null, 0, null, null);\r
+ for(TaxonBase taxonBase : synonymList){\r
+ if(taxonBase instanceof Synonym){\r
+ Set<Taxon> acceptetdCandidates = ((Synonym)taxonBase).getAcceptedTaxa();\r
+ if(!acceptetdCandidates.isEmpty()){\r
+ matchedTaxon = acceptetdCandidates.iterator().next();\r
+ if(acceptetdCandidates.size() == 1){\r
+ logger.info(acceptetdCandidates.size() + " Accepted taxa found for synonym " + taxonBase.getTitleCache() + ", using first one: " + matchedTaxon.getTitleCache());\r
+ return matchedTaxon;\r
+ } else {\r
+ logger.info("using accepted Taxon " + matchedTaxon.getTitleCache() + "for synonym " + taxonBase.getTitleCache());\r
+ return matchedTaxon;\r
+ }\r
+ //TODO extend method: search using treeUUID, using SecUUID, first find accepted then include synonyms until a matching taxon is found\r
+ }\r
+ }\r
+ }\r
+ \r
+ } catch (Exception e){\r
+ logger.error(e);\r
+ }\r
+ \r
+ return matchedTaxon;\r
+ }\r
+\r
+ /* (non-Javadoc)\r
+ * @see eu.etaxonomy.cdm.api.service.ITaxonService#findBestMatchingSynonym(java.lang.String)\r
+ */\r
+ @Override\r
+ public Synonym findBestMatchingSynonym(String taxonName) {\r
+ List<TaxonBase> synonymList = dao.findByNameTitleCache(Synonym.class, taxonName, null, MatchMode.EXACT, null, 0, null, null);\r
+ if(! synonymList.isEmpty()){\r
+ Synonym result = CdmBase.deproxy(synonymList.iterator().next(), Synonym.class);\r
+ if(synonymList.size() == 1){\r
+ logger.info(synonymList.size() + " Synonym found " + result.getTitleCache() );\r
+ return result;\r
+ } else {\r
+ logger.info("Several matching synonyms found. Using first: " + result.getTitleCache());\r
+ return result;\r
+ }\r
+ }\r
+ return null;\r
}\r
- //TODO\r
- public void generateTitleCache(boolean forceProtected) {\r
- logger.warn("generateTitleCache not yet fully implemented!");\r
-// for (TaxonBase tb : taxonDao.getAllTaxa(null,null)){\r
-// logger.warn("Old taxon title: " + tb.getTitleCache());\r
-// if (forceProtected || !tb.isProtectedTitleCache() ){\r
-// tb.setTitleCache(tb.generateTitle(), false);\r
-// taxonDao.update(tb);\r
-// logger.warn("New title: " + tb.getTitleCache());\r
-// }\r
-// }\r
+\r
+ /* (non-Javadoc)\r
+ * @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)\r
+ */\r
+ @Override\r
+ public Taxon moveSynonymToAnotherTaxon(SynonymRelationship synonymRelation,\r
+ Taxon toTaxon, SynonymRelationshipType synonymRelationshipType, Reference reference, String referenceDetail) {\r
+ Taxon fromTaxon = synonymRelation.getAcceptedTaxon();\r
+\r
+ toTaxon.addSynonym(synonymRelation.getSynonym(), synonymRelationshipType, reference, referenceDetail);\r
\r
+ fromTaxon.removeSynonymRelation(synonymRelation);\r
+ \r
+ return toTaxon;\r
+ }\r
+\r
+ /* (non-Javadoc)\r
+ * @see eu.etaxonomy.cdm.api.service.ITaxonService#getUuidAndTitleCacheTaxon()\r
+ */\r
+ @Override\r
+ public List<UuidAndTitleCache<TaxonBase>> getUuidAndTitleCacheTaxon() {\r
+ return dao.getUuidAndTitleCacheTaxon();\r
+ }\r
+\r
+ /* (non-Javadoc)\r
+ * @see eu.etaxonomy.cdm.api.service.ITaxonService#getUuidAndTitleCacheSynonym()\r
+ */\r
+ @Override\r
+ public List<UuidAndTitleCache<TaxonBase>> getUuidAndTitleCacheSynonym() {\r
+ return dao.getUuidAndTitleCacheSynonym();\r
}\r
+ \r
+ \r
}\r
BGBM BDI Projects / cdmlib.git / blobdiff