cdmlib-services/src/main/java/eu/etaxonomy/cdm/api/service/NameServiceImpl.java

   1 // $Id$
   2 /**
   3 * Copyright (C) 2007 EDIT
   4 * European Distributed Institute of Taxonomy
   5 * http://www.e-taxonomy.eu
   6 *
   7 * The contents of this file are subject to the Mozilla Public License Version 1.1
   8 * See LICENSE.TXT at the top of this package for the full license terms.
   9 */
  10
  11 package eu.etaxonomy.cdm.api.service;
  12
  13 import java.util.ArrayList;
  14 import java.util.Collection;
  15 import java.util.List;
  16 import java.util.Map;
  17 import java.util.Set;
  18 import java.util.UUID;
  19
  20 import org.apache.log4j.Logger;
  21 import org.springframework.beans.factory.annotation.Autowired;
  22 import org.springframework.beans.factory.annotation.Qualifier;
  23 import org.springframework.stereotype.Service;
  24 import org.springframework.transaction.annotation.Transactional;
  25
  26 import eu.etaxonomy.cdm.api.service.config.IIdentifiableEntityServiceConfigurator;
  27 import eu.etaxonomy.cdm.api.service.config.INameServiceConfigurator;
  28 import eu.etaxonomy.cdm.api.service.pager.Pager;
  29 import eu.etaxonomy.cdm.api.service.pager.impl.DefaultPagerImpl;
  30 import eu.etaxonomy.cdm.model.common.Annotation;
  31 import eu.etaxonomy.cdm.model.common.CdmBase;
  32 import eu.etaxonomy.cdm.model.common.OrderedTermVocabulary;
  33 import eu.etaxonomy.cdm.model.common.ReferencedEntityBase;
  34 import eu.etaxonomy.cdm.model.common.RelationshipBase;
  35 import eu.etaxonomy.cdm.model.common.RelationshipTermBase;
  36 import eu.etaxonomy.cdm.model.common.TermVocabulary;
  37 import eu.etaxonomy.cdm.model.name.BotanicalName;
  38 import eu.etaxonomy.cdm.model.name.HomotypicalGroup;
  39 import eu.etaxonomy.cdm.model.name.HybridRelationship;
  40 import eu.etaxonomy.cdm.model.name.HybridRelationshipType;
  41 import eu.etaxonomy.cdm.model.name.NameRelationship;
  42 import eu.etaxonomy.cdm.model.name.NameRelationshipType;
  43 import eu.etaxonomy.cdm.model.name.NomenclaturalStatus;
  44 import eu.etaxonomy.cdm.model.name.NomenclaturalStatusType;
  45 import eu.etaxonomy.cdm.model.name.NonViralName;
  46 import eu.etaxonomy.cdm.model.name.Rank;
  47 import eu.etaxonomy.cdm.model.name.TaxonNameBase;
  48 import eu.etaxonomy.cdm.model.name.TypeDesignationBase;
  49 import eu.etaxonomy.cdm.model.name.SpecimenTypeDesignationStatus;
  50 import eu.etaxonomy.cdm.model.name.TypeDesignationStatusBase;
  51 import eu.etaxonomy.cdm.model.taxon.TaxonBase;
  52 import eu.etaxonomy.cdm.persistence.dao.common.IOrderedTermVocabularyDao;
  53 import eu.etaxonomy.cdm.persistence.dao.common.IReferencedEntityDao;
  54 import eu.etaxonomy.cdm.persistence.dao.common.ITermVocabularyDao;
  55 import eu.etaxonomy.cdm.persistence.dao.name.IHomotypicalGroupDao;
  56 import eu.etaxonomy.cdm.persistence.dao.name.INomenclaturalStatusDao;
  57 import eu.etaxonomy.cdm.persistence.dao.name.ITaxonNameDao;
  58 import eu.etaxonomy.cdm.persistence.dao.name.ITypeDesignationDao;
  59 import eu.etaxonomy.cdm.persistence.query.MatchMode;
  60 import eu.etaxonomy.cdm.persistence.query.OrderHint;
  61
  62
  63 @Service
  64 @Transactional(readOnly = true)
  65 public class NameServiceImpl extends IdentifiableServiceBase<TaxonNameBase,ITaxonNameDao> implements INameService {
  66         static private final Logger logger = Logger.getLogger(NameServiceImpl.class);
  67
  68         @Autowired
  69         protected ITermVocabularyDao vocabularyDao;
  70         @Autowired
  71         protected IOrderedTermVocabularyDao orderedVocabularyDao;
  72         @Autowired
  73         @Qualifier("refEntDao")
  74     protected IReferencedEntityDao<ReferencedEntityBase> referencedEntityDao;
  75         @Autowired
  76         private INomenclaturalStatusDao nomStatusDao;
  77         @Autowired
  78         private ITypeDesignationDao typeDesignationDao;
  79         @Autowired
  80         private IHomotypicalGroupDao homotypicalGroupDao;
  81
  82         /**
  83          * Constructor
  84          */
  85         public NameServiceImpl(){
  86                 if (logger.isDebugEnabled()) { logger.debug("Load NameService Bean"); }
  87         }
  88
  89 //********************* METHODS ****************************************************************//
  90
  91         public List getNamesByName(String name){
  92                 return super.findCdmObjectsByTitle(name);
  93         }
  94
  95         public List<NonViralName> getNamesByNameCache(String nameCache){
  96                 List result = dao.findByName(nameCache, MatchMode.EXACT, null, null, null, null);
  97                 return result;
  98         }
  99
 100         public List getNamesByName(String name, CdmBase sessionObject){
 101                 return super.findCdmObjectsByTitle(name, sessionObject);
 102         }
 103
 104         public List findNamesByTitle(String title){
 105                 return super.findCdmObjectsByTitle(title);
 106         }
 107
 108         public List findNamesByTitle(String title, CdmBase sessionObject){
 109                 return super.findCdmObjectsByTitle(title, sessionObject);
 110         }
 111
 112         public List<TaxonNameBase> findByTitle(IIdentifiableEntityServiceConfigurator config) {
 113                 return super.findByTitle(config);
 114         }
 115
 116         public TaxonNameBase<?,?> getTaxonNameByUuid(UUID uuid) {
 117                 return super.getCdmObjectByUuid(uuid);
 118         }
 119
 120         @Transactional(readOnly = false)
 121         public UUID saveTaxonName(TaxonNameBase taxonName) {
 122                 return super.saveCdmObject(taxonName);
 123         }
 124
 125         @Transactional(readOnly = false)
 126         public Map<UUID, TaxonNameBase> saveTaxonNameAll(Collection<? extends TaxonNameBase> taxonNameCollection){
 127                 return saveCdmObjectAll(taxonNameCollection);
 128         }
 129
 130         @Transactional(readOnly = false)
 131         public Map<UUID, HomotypicalGroup> saveAllHomotypicalGroups(Collection<HomotypicalGroup> homotypicalGroups){
 132                 return homotypicalGroupDao.saveAll(homotypicalGroups);
 133         }
 134
 135         @Transactional(readOnly = false)
 136         public Map<UUID, TypeDesignationBase> saveTypeDesignationAll(Collection<TypeDesignationBase> typeDesignationCollection){
 137                 return typeDesignationDao.saveAll(typeDesignationCollection);
 138         }
 139
 140         @Transactional(readOnly = false)
 141         public Map<UUID, ReferencedEntityBase> saveReferencedEntitiesAll(Collection<ReferencedEntityBase> referencedEntityCollection){
 142                 return referencedEntityDao.saveAll(referencedEntityCollection);
 143         }
 144
 145         @Transactional(readOnly = false)
 146         public UUID removeTaxonName(TaxonNameBase taxonName) {
 147                 return super.removeCdmObject(taxonName);
 148         }
 149
 150         public List<TaxonNameBase> getAllNames(int limit, int start){
 151                 return dao.list(limit, start);
 152         }
 153
 154         public List<NomenclaturalStatus> getAllNomenclaturalStatus(int limit, int start){
 155                 return nomStatusDao.list(limit, start);
 156         }
 157
 158         public List<TypeDesignationBase> getAllTypeDesignations(int limit, int start){
 159                 return typeDesignationDao.getAllTypeDesignations(limit, start);
 160         }
 161          /**
 162          * FIXME Candidate for harmonization
 163          * homotypicalGroupService.list
 164          */
 165         public List<HomotypicalGroup> getAllHomotypicalGroups(int limit, int start){
 166                 return homotypicalGroupDao.list(limit, start);
 167         }
 168
 169         /**
 170          * FIXME Candidate for harmonization
 171          * remove
 172          */
 173         @Deprecated
 174         public List<RelationshipBase> getAllRelationships(int limit, int start){
 175                 return dao.getAllRelationships(limit, start);
 176         }
 177
 178         /**
 179          * FIXME Candidate for harmonization
 180          * is this the same as termService.getVocabulary(VocabularyEnum.Rank)
 181          * (non-Javadoc)
 182          * @see eu.etaxonomy.cdm.api.service.INameService#getRankVocabulary()
 183          */
 184         public OrderedTermVocabulary<Rank> getRankVocabulary() {
 185                 String uuidString = "ef0d1ce1-26e3-4e83-b47b-ca74eed40b1b";
 186                 UUID uuid = UUID.fromString(uuidString);
 187                 OrderedTermVocabulary<Rank> rankVocabulary =
 188                         (OrderedTermVocabulary)orderedVocabularyDao.findByUuid(uuid);
 189                 return rankVocabulary;
 190         }
 191
 192         /**
 193          * FIXME Candidate for harmonization
 194          * is this the same as termService.getVocabulary(VocabularyEnum.NameRelationshipType)
 195          *  (non-Javadoc)
 196          * @see eu.etaxonomy.cdm.api.service.INameService#getNameRelationshipTypeVocabulary()
 197          */
 198         public TermVocabulary<NameRelationshipType> getNameRelationshipTypeVocabulary() {
 199                 String uuidString = "6878cb82-c1a4-4613-b012-7e73b413c8cd";
 200                 UUID uuid = UUID.fromString(uuidString);
 201                 TermVocabulary<NameRelationshipType> nameRelTypeVocabulary =
 202                         (TermVocabulary)vocabularyDao.findByUuid(uuid);
 203                 return nameRelTypeVocabulary;
 204         }
 205
 206         /**
 207          * FIXME Candidate for harmonization
 208          * is this the same as termService.getVocabulary(VocabularyEnum.StatusType)
 209          * (non-Javadoc)
 210          * @see eu.etaxonomy.cdm.api.service.INameService#getStatusTypeVocabulary()
 211          */
 212         public TermVocabulary<NomenclaturalStatusType> getStatusTypeVocabulary() {
 213                 String uuidString = "bb28cdca-2f8a-4f11-9c21-517e9ae87f1f";
 214                 UUID uuid = UUID.fromString(uuidString);
 215                 TermVocabulary<NomenclaturalStatusType> nomStatusTypeVocabulary =
 216                         (TermVocabulary)vocabularyDao.findByUuid(uuid);
 217                 return nomStatusTypeVocabulary;
 218         }
 219
 220         /**
 221          * FIXME Candidate for harmonization
 222          * is this the same as termService.getVocabulary(VocabularyEnum.SpecimenTypeDesignationStatus)
 223          *  (non-Javadoc)
 224          * @see eu.etaxonomy.cdm.api.service.INameService#getTypeDesignationStatusVocabulary()
 225          */
 226         public TermVocabulary<SpecimenTypeDesignationStatus> getSpecimenTypeDesignationStatusVocabulary() {
 227                 String uuidString = "ab177bd7-d3c8-4e58-a388-226fff6ba3c2";
 228                 UUID uuid = UUID.fromString(uuidString);
 229                 TermVocabulary<SpecimenTypeDesignationStatus> typeDesigStatusVocabulary =
 230                         (TermVocabulary)vocabularyDao.findByUuid(uuid);
 231                 return typeDesigStatusVocabulary;
 232         }
 233
 234         /**
 235          * FIXME Candidate for harmonization
 236          * is this the same as termService.getVocabulary(VocabularyEnum.SpecimenTypeDesignationStatus)
 237          * and also seems to duplicate the above method, differing only in the DAO used and the return type
 238          * (non-Javadoc)
 239          * @see eu.etaxonomy.cdm.api.service.INameService#getTypeDesignationStatusVocabulary()
 240          */
 241         public OrderedTermVocabulary<SpecimenTypeDesignationStatus> getSpecimenTypeDesignationVocabulary() {
 242                 String uuidString = "ab177bd7-d3c8-4e58-a388-226fff6ba3c2";
 243                 UUID uuid = UUID.fromString(uuidString);
 244                 OrderedTermVocabulary<SpecimenTypeDesignationStatus> typeDesignationVocabulary =
 245                         (OrderedTermVocabulary)orderedVocabularyDao.findByUuid(uuid);
 246                 return typeDesignationVocabulary;
 247         }
 248
 249         public void generateTitleCache() {
 250                 logger.warn("Not yet implemented");
 251                 // TODO Auto-generated method stub
 252         }
 253
 254         @Autowired
 255         protected void setDao(ITaxonNameDao dao) {
 256                 this.dao = dao;
 257         }
 258
 259         public Pager<HybridRelationship> getHybridNames(BotanicalName name,     HybridRelationshipType type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
 260         Integer numberOfResults = dao.countHybridNames(name, type);
 261
 262                 List<HybridRelationship> results = new ArrayList<HybridRelationship>();
 263                 if(numberOfResults > 0) { // no point checking again
 264                         results = dao.getHybridNames(name, type, pageSize, pageNumber,orderHints,propertyPaths);
 265                 }
 266
 267                 return new DefaultPagerImpl<HybridRelationship>(pageNumber, numberOfResults, pageSize, results);
 268         }
 269
 270         public List<NameRelationship> listFromNameRelationships(TaxonNameBase name, NameRelationshipType type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
 271                 Integer numberOfResults = dao.countNameRelationships(name, NameRelationship.Direction.relatedFrom, type);
 272
 273                 List<NameRelationship> results = new ArrayList<NameRelationship>();
 274                 if(numberOfResults > 0) { // no point checking again
 275                         results = dao.getNameRelationships(name, NameRelationship.Direction.relatedFrom, type, pageSize, pageNumber, orderHints, propertyPaths);
 276                 }
 277                 return results;
 278         }
 279
 280         public Pager<NameRelationship> pageFromNameRelationships(TaxonNameBase name, NameRelationshipType type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
 281         Integer numberOfResults = dao.countNameRelationships(name, NameRelationship.Direction.relatedFrom, type);
 282
 283                 List<NameRelationship> results = new ArrayList<NameRelationship>();
 284                 if(numberOfResults > 0) { // no point checking again
 285                         results = dao.getNameRelationships(name, NameRelationship.Direction.relatedFrom, type, pageSize, pageNumber, orderHints, propertyPaths);
 286                 }
 287                 return new DefaultPagerImpl<NameRelationship>(pageNumber, numberOfResults, pageSize, results);
 288         }
 289
 290         public List<NameRelationship> listToNameRelationships(TaxonNameBase name, NameRelationshipType type,
 291                         Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
 292
 293                 Integer numberOfResults = dao.countNameRelationships(name, NameRelationship.Direction.relatedTo, type);
 294
 295                 List<NameRelationship> results = new ArrayList<NameRelationship>();
 296                 if (numberOfResults > 0) { // no point checking again
 297                         results = dao.getNameRelationships(name, NameRelationship.Direction.relatedTo, type, pageSize, pageNumber,
 298                                 orderHints, propertyPaths);
 299                 }
 300                 return results;
 301         }
 302
 303         public Pager<NameRelationship> pageToNameRelationships(TaxonNameBase name, NameRelationshipType type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
 304                 Integer numberOfResults = dao.countNameRelationships(name, NameRelationship.Direction.relatedTo, type);
 305
 306                 List<NameRelationship> results = new ArrayList<NameRelationship>();
 307                 if (numberOfResults > 0) { // no point checking again
 308                         results = dao.getNameRelationships(name, NameRelationship.Direction.relatedTo, type, pageSize, pageNumber,
 309                                 orderHints, propertyPaths);
 310                 }
 311
 312                 return new DefaultPagerImpl<NameRelationship>(pageNumber, numberOfResults, pageSize, results);
 313         }
 314
 315
 316         public Pager<TypeDesignationBase> getTypeDesignations(TaxonNameBase name, SpecimenTypeDesignationStatus status,
 317                         Integer pageSize, Integer pageNumber) {
 318                 return getTypeDesignations(name, status, pageSize, pageNumber, null);
 319         }
 320
 321         public Pager<TypeDesignationBase> getTypeDesignations(TaxonNameBase name, SpecimenTypeDesignationStatus status,
 322                                 Integer pageSize, Integer pageNumber, List<String> propertyPaths){
 323         Integer numberOfResults = dao.countTypeDesignations(name, status);
 324
 325                 List<TypeDesignationBase> results = new ArrayList<TypeDesignationBase>();
 326                 if(numberOfResults > 0) { // no point checking again
 327                         results = dao.getTypeDesignations(name, status, pageSize, pageNumber, propertyPaths);
 328                 }
 329
 330                 return new DefaultPagerImpl<TypeDesignationBase>(pageNumber, numberOfResults, pageSize, results);
 331         }
 332
 333     /**
 334      * FIXME Candidate for harmonization
 335          * rename search
 336      */
 337         public Pager<TaxonNameBase> searchNames(String uninomial,String infraGenericEpithet, String specificEpithet, String infraspecificEpithet, Rank rank, Integer pageSize,  Integer pageNumber, List<OrderHint> orderHints,
 338                         List<String> propertyPaths) {
 339         Integer numberOfResults = dao.countNames(uninomial, infraGenericEpithet, specificEpithet, infraspecificEpithet, rank);
 340
 341                 List<TaxonNameBase> results = new ArrayList<TaxonNameBase>();
 342                 if(numberOfResults > 0) { // no point checking again
 343                         results = dao.searchNames(uninomial, infraGenericEpithet, specificEpithet, infraspecificEpithet, rank, pageSize, pageNumber, orderHints, propertyPaths);
 344                 }
 345
 346                 return new DefaultPagerImpl<TaxonNameBase>(pageNumber, numberOfResults, pageSize, results);
 347         }
 348
 349         public Pager<TaxonNameBase> search(Class<? extends TaxonNameBase> clazz, String queryString, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
 350         Integer numberOfResults = dao.count(clazz,queryString);
 351
 352                 List<TaxonNameBase> results = new ArrayList<TaxonNameBase>();
 353                 if(numberOfResults > 0) { // no point checking again
 354                         results = dao.search(clazz,queryString, pageSize, pageNumber, orderHints, propertyPaths);
 355                 }
 356
 357                 return new DefaultPagerImpl<TaxonNameBase>(pageNumber, numberOfResults, pageSize, results);
 358         }
 359
 360         /* (non-Javadoc)
 361          * @see eu.etaxonomy.cdm.api.service.INameService#getUuidAndTitleCacheOfNames()
 362          */
 363         public Map<UUID, String> getUuidAndTitleCacheOfNames() {
 364                 return dao.getUuidAndTitleCacheOfNames();
 365         }
 366
 367         /* (non-Javadoc)
 368          * @see eu.etaxonomy.cdm.api.service.IService#list(java.lang.Class, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List)
 369          */
 370         public <TYPE extends TaxonNameBase> Pager<TYPE> list(Class<TYPE> type,
 371                         Integer pageSize, Integer pageNumber, List<OrderHint> orderHints,
 372                         List<String> propertyPaths) {
 373                 // TODO Auto-generated method stub
 374                 return null;
 375         }
 376 }