cdmlib-services/src/main/java/eu/etaxonomy/cdm/api/service/TermServiceImpl.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.Enumeration;
  16 import java.util.List;
  17 import java.util.Locale;
  18 import java.util.Map;
  19 import java.util.Set;
  20 import java.util.UUID;
  21
  22 import org.apache.log4j.Logger;
  23 import org.springframework.beans.factory.annotation.Autowired;
  24 import org.springframework.beans.factory.annotation.Qualifier;
  25 import org.springframework.stereotype.Service;
  26 import org.springframework.transaction.annotation.Transactional;
  27
  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.DefinedTermBase;
  31 import eu.etaxonomy.cdm.model.common.Language;
  32 import eu.etaxonomy.cdm.model.common.LanguageString;
  33 import eu.etaxonomy.cdm.model.common.LanguageStringBase;
  34 import eu.etaxonomy.cdm.model.common.OrderedTermVocabulary;
  35 import eu.etaxonomy.cdm.model.common.Representation;
  36 import eu.etaxonomy.cdm.model.common.TermVocabulary;
  37 import eu.etaxonomy.cdm.model.common.VocabularyEnum;
  38 import eu.etaxonomy.cdm.model.location.NamedArea;
  39 import eu.etaxonomy.cdm.model.location.NamedAreaLevel;
  40 import eu.etaxonomy.cdm.model.location.NamedAreaType;
  41 import eu.etaxonomy.cdm.model.location.TdwgArea;
  42 import eu.etaxonomy.cdm.model.media.Media;
  43 import eu.etaxonomy.cdm.model.name.NameRelationship;
  44 import eu.etaxonomy.cdm.persistence.dao.common.IDefinedTermDao;
  45 import eu.etaxonomy.cdm.persistence.dao.common.ILanguageStringBaseDao;
  46 import eu.etaxonomy.cdm.persistence.dao.common.ILanguageStringDao;
  47 import eu.etaxonomy.cdm.persistence.dao.common.IRepresentationDao;
  48 import eu.etaxonomy.cdm.persistence.dao.common.ITermVocabularyDao;
  49 import eu.etaxonomy.cdm.persistence.query.OrderHint;
  50
  51 @Service
  52 @Transactional(readOnly = true)
  53 public class TermServiceImpl extends ServiceBase<DefinedTermBase,IDefinedTermDao> implements ITermService{
  54         private static final Logger logger = Logger.getLogger(TermServiceImpl.class);
  55
  56         protected ITermVocabularyDao vocabularyDao;
  57         @Autowired
  58         @Qualifier("langStrBaseDao")
  59         private ILanguageStringBaseDao languageStringBaseDao;
  60         @Autowired
  61         private IRepresentationDao representationDao;
  62         @Autowired
  63         private ILanguageStringDao languageStringDao;
  64
  65         @Autowired
  66         protected void setVocabularyDao(ITermVocabularyDao vocabularyDao) {
  67                 this.vocabularyDao = vocabularyDao;
  68         }
  69
  70         /**
  71          *  (non-Javadoc)
  72          * @see eu.etaxonomy.cdm.api.service.ITermService#getTermByUri(java.lang.String)
  73          * FIXME Candidate for harmonization
  74          * rename -> getByUri
  75          */
  76         public DefinedTermBase getTermByUri(String uri) {
  77                 //FIXME transformation from URI to UUID
  78                 return dao.findByUri(uri);
  79         }
  80
  81         /**
  82          *  (non-Javadoc)
  83          * @see eu.etaxonomy.cdm.api.service.ITermService#getTermByUuid(java.util.UUID)
  84          * FIXME candidate for harmonization
  85          */
  86         public DefinedTermBase getTermByUuid(UUID uuid) {
  87                 return dao.findByUuid(uuid);
  88         }
  89
  90         public DefinedTermBase loadTerm(UUID uuid, List<String> propertyPaths){
  91                 return dao.load(uuid, propertyPaths);
  92         }
  93
  94         /**
  95          * FIXME candidate for harmonization
  96          * list
  97          */
  98         public List<DefinedTermBase> getAllDefinedTerms(int limit, int start){
  99                 return dao.list(limit, start);
 100         }
 101
 102         /**
 103          * FIXME candidate for harmonization
 104          * save
 105          */
 106         @Transactional(readOnly = false)
 107         public UUID saveTerm(DefinedTermBase termBase) {
 108                 return super.saveCdmObject(termBase);
 109         }
 110
 111         /**
 112          * FIXME candidate for harmonization
 113          * save(Set<DefinedTermBase> terms)
 114          */
 115         @Transactional(readOnly = false)
 116         public Map<UUID, DefinedTermBase> saveTermsAll(Collection<? extends DefinedTermBase> termBaseCollection){
 117                 return saveCdmObjectAll(termBaseCollection);
 118         }
 119
 120         /**
 121          *  (non-Javadoc)
 122          * @see eu.etaxonomy.cdm.api.service.ITermService#getVocabulary(java.util.UUID)
 123          * FIXME candidate for harmonization
 124          * vocabuaryService.find
 125          */
 126         public TermVocabulary<? extends DefinedTermBase<?>> getVocabulary(UUID vocabularyUuid) {
 127                 TermVocabulary<? extends DefinedTermBase<?>> vocabulary = (TermVocabulary) vocabularyDao.findByUuid(vocabularyUuid);
 128                 return vocabulary;
 129         }
 130
 131         /**
 132          * FIXME candidate for harmonization
 133          * vocabularyService.load
 134          */
 135         public TermVocabulary loadVocabulary(UUID vocabularyUuid, List<String> propertyPaths) {
 136                 TermVocabulary<? extends DefinedTermBase<?>> vocabulary = (TermVocabulary) vocabularyDao.load(vocabularyUuid,
 137                         propertyPaths);
 138                 return vocabulary;
 139         }
 140
 141         /**
 142          * FIXME candidate for harmonization
 143          * move to vocabularyService
 144          */
 145         public TermVocabulary<? extends DefinedTermBase<?>> getVocabulary(VocabularyEnum vocabularyType){
 146                 TermVocabulary<? extends DefinedTermBase<?>> vocabulary = getVocabulary(vocabularyType.getUuid());
 147                 return vocabulary;
 148         }
 149
 150         /**
 151          *  (non-Javadoc)
 152          * @see eu.etaxonomy.cdm.api.service.ITermService#listVocabularies(java.lang.Class)
 153          * FIXME candidate for harmonization
 154          * vocabularyService.list
 155          */
 156         public Set<TermVocabulary> listVocabularies(Class termClass) {
 157                 logger.error("Method not implemented yet");
 158                 return null;
 159         }
 160
 161         /**
 162          * FIXME candidate for harmonization
 163          * vocabularyService.list
 164          */
 165         public List<TermVocabulary<DefinedTermBase>> getAllTermVocabularies(int limit, int start) {
 166                 return vocabularyDao.list(limit, start);
 167         }
 168
 169         public List<TermVocabulary<DefinedTermBase>> listTermVocabularies(Integer limit, Integer start, List<OrderHint> orderHints,
 170                 List<String> propertyPaths){
 171                 return vocabularyDao.list(limit, start, orderHints, propertyPaths);
 172         }
 173
 174         /**
 175          * FIXME candidate for harmonization
 176          * vocabularyService.page
 177          */
 178         public Pager<TermVocabulary<DefinedTermBase>> pageTermVocabularies(Integer pageSize, Integer pageNumber,
 179                         List<OrderHint> orderHints, List<String> propertyPaths) {
 180
 181                 List<TermVocabulary<DefinedTermBase>> vocabs = vocabularyDao.list(pageSize, pageNumber * pageSize, orderHints,
 182                         propertyPaths);
 183                 Pager<TermVocabulary<DefinedTermBase>> pager = new DefaultPagerImpl<TermVocabulary<DefinedTermBase>>(
 184                         pageNumber, vocabs.size(), pageSize, vocabs);
 185                 return pager;
 186         }
 187
 188         /**
 189          * (non-Javadoc)
 190          * @see eu.etaxonomy.cdm.api.service.ITermService#getLanguageVocabulary()
 191          * FIXME candidate for harmonization
 192          * is this the same as getVocabulary(VocabularyEnum.Language)
 193          */
 194         public TermVocabulary<Language> getLanguageVocabulary() {
 195                 String uuidString = "45ac7043-7f5e-4f37-92f2-3874aaaef2de";
 196                 UUID uuid = UUID.fromString(uuidString);
 197                 TermVocabulary<Language> languageVocabulary =
 198                         (TermVocabulary)vocabularyDao.findByUuid(uuid);
 199                 return languageVocabulary;
 200         }
 201
 202         /**
 203          * FIXME candidate for harmonization
 204          * vocabularyService.save(Set<TermVocabulary> vocabularies)
 205          */
 206         public Map<UUID, TermVocabulary<DefinedTermBase>>
 207     saveTermVocabulariesAll(Collection<TermVocabulary<DefinedTermBase>> termVocabularies) {
 208                 return vocabularyDao.saveAll(termVocabularies);
 209         }
 210
 211         public UUID saveTermVocabulary(TermVocabulary termVocabulary) {
 212                 return vocabularyDao.save(termVocabulary);
 213         }
 214
 215         /**
 216          * FIXME candidate for harmonization
 217          * remove redundant code
 218          */
 219 //      @Transactional(readOnly = false)
 220 //      public Map<UUID, Representation> saveRepresentationsAll(Collection<Representation> representations){
 221 //              return representationDao.saveAll(representations);
 222 //      }
 223
 224         /**
 225          * FIXME candidate for harmonization
 226          * this code is not used, remove it
 227          */
 228         @Transactional(readOnly = false)
 229         public Map<UUID, LanguageStringBase> saveLanguageDataAll(Collection<LanguageStringBase> languageData) {
 230                 return languageStringBaseDao.saveAll(languageData);
 231         }
 232
 233         /**
 234          * FIXME candidate for harmonization
 235          * Given that representations are owned by TermBase, this method is redundant
 236          * @param representations
 237          * @return
 238          */
 239         @Transactional(readOnly = false)
 240         public Map<UUID, Representation> saveRepresentationAll(Collection<Representation> representations) {
 241                 return representationDao.saveAll(representations);
 242         }
 243
 244         /**
 245          * FIXME candidate for harmonization
 246          * Given that representations are owned by TermBase, this method is redundant
 247          */
 248         public List<Representation> getAllRepresentations(int limit, int start){
 249                 return representationDao.list(limit, start);
 250         }
 251
 252         /**
 253          * FIXME candidate for harmonization
 254          * Given that languageStrings are owned by other objects, this method is redundant
 255          */
 256         public List<LanguageString> getAllLanguageStrings(int limit, int start) {
 257                 return languageStringDao.list(limit, start);
 258         }
 259
 260         /**
 261          * FIXME candidate for harmonization
 262          * Given that languageStrings are owned by other objects, this method is redundant
 263          */
 264         public Map<UUID, LanguageStringBase>
 265                saveLanguageStringBasesAll(Collection<LanguageStringBase> languageStringBases) {
 266                 return languageStringBaseDao.saveAll(languageStringBases);
 267         }
 268
 269         public Language getLanguageByIso(String iso639) {
 270                 return dao.getLanguageByIso(iso639);
 271         }
 272
 273         public List<Language> getLanguagesByLocale(Enumeration<Locale> locales){
 274                 return dao.getLanguagesByLocale(locales);
 275         }
 276
 277         /**
 278          * FIXME candidate for harmonization
 279          * Given that languageStrings are owned by other objects, this method is redundant
 280          */
 281         @Transactional(readOnly = false)
 282         public UUID saveLanguageData(
 283                         LanguageStringBase languageData) {
 284                         return languageStringBaseDao.save(languageData);
 285         }
 286
 287         @Autowired
 288         protected void setDao(IDefinedTermDao dao) {
 289                 this.dao = dao;
 290         }
 291
 292         /**
 293          *  (non-Javadoc)
 294          * @see eu.etaxonomy.cdm.api.service.ITermService#getAreaByTdwgAbbreviation(java.lang.String)
 295          */
 296         public NamedArea getAreaByTdwgAbbreviation(String tdwgAbbreviation) {
 297                 //FIXME this is just a placeholder until it is decided where to implement this method
 298                 //(see also FIXMEs in TdwgArea)
 299                 return TdwgArea.getAreaByTdwgAbbreviation(tdwgAbbreviation);
 300         }
 301
 302         public <T extends DefinedTermBase> Pager<T> getGeneralizationOf(T definedTerm, Integer pageSize, Integer pageNumber) {
 303         Integer numberOfResults = dao.countGeneralizationOf(definedTerm);
 304
 305                 List<T> results = new ArrayList<T>();
 306                 if(numberOfResults > 0) { // no point checking again
 307                         results = dao.getGeneralizationOf(definedTerm, pageSize, pageNumber);
 308                 }
 309
 310                 return new DefaultPagerImpl<T>(pageNumber, numberOfResults, pageSize, results);
 311         }
 312
 313         public <T extends DefinedTermBase> Pager<T> getIncludes(Set<T> definedTerms, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
 314         Integer numberOfResults = dao.countIncludes(definedTerms);
 315
 316                 List<T> results = new ArrayList<T>();
 317                 if(numberOfResults > 0) { // no point checking again
 318                         results = dao.getIncludes(definedTerms, pageSize, pageNumber,propertyPaths);
 319                 }
 320
 321                 return new DefaultPagerImpl<T>(pageNumber, numberOfResults, pageSize, results);
 322         }
 323
 324         public Pager<Media> getMedia(DefinedTermBase definedTerm, Integer pageSize,     Integer pageNumber) {
 325         Integer numberOfResults = dao.countMedia(definedTerm);
 326
 327                 List<Media> results = new ArrayList<Media>();
 328                 if(numberOfResults > 0) { // no point checking again
 329                         results = dao.getMedia(definedTerm, pageSize, pageNumber);
 330                 }
 331
 332                 return new DefaultPagerImpl<Media>(pageNumber, numberOfResults, pageSize, results);
 333         }
 334
 335         public <T extends DefinedTermBase> Pager<T> getPartOf(Set<T> definedTerms,Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
 336         Integer numberOfResults = dao.countPartOf(definedTerms);
 337
 338                 List<T> results = new ArrayList<T>();
 339                 if(numberOfResults > 0) { // no point checking again
 340                         results = dao.getPartOf(definedTerms, pageSize, pageNumber, propertyPaths);
 341                 }
 342
 343                 return new DefaultPagerImpl<T>(pageNumber, numberOfResults, pageSize, results);
 344         }
 345
 346         public Pager<NamedArea> list(NamedAreaLevel level, NamedAreaType type, Integer pageSize, Integer pageNumber,
 347                         List<OrderHint> orderHints, List<String> propertyPaths) {
 348                 Integer numberOfResults = dao.count(level, type);
 349
 350                 List<NamedArea> results = new ArrayList<NamedArea>();
 351                 if (numberOfResults > 0) { // no point checking again
 352                         results = dao.list(level, type, pageSize, pageNumber, orderHints, propertyPaths);
 353                 }
 354
 355                 return new DefaultPagerImpl<NamedArea>(pageNumber, numberOfResults, pageSize, results);
 356         }
 357
 358         public <T extends DefinedTermBase> Pager<T> findByRepresentationText(String label, Class<T> clazz, Integer pageSize, Integer pageNumber) {
 359         Integer numberOfResults = dao.countDefinedTermByRepresentationText(label,clazz);
 360
 361                 List<T> results = new ArrayList<T>();
 362                 if(numberOfResults > 0) { // no point checking again
 363                         results = dao.getDefinedTermByRepresentationText(label, clazz, pageSize, pageNumber);
 364                 }
 365
 366                 return new DefaultPagerImpl<T>(pageNumber, numberOfResults, pageSize, results);
 367         }
 368 }